// De drie array-methodes die je overal ziet
const orders = [
  { id: 1, status: 'open', duur: 60 },
  { id: 2, status: 'gepland', duur: 90 },
  { id: 3, status: 'open', duur: 45 },
];
const openOrders = orders.filter(o => o.status === 'open');     // [1, 3]
const namen      = orders.map(o => `Order ${o.id}`);              // ["Order 1", ...]
const totaalMin  = orders.reduce((som, o) => som + o.duur, 0);    // 195

async function laadTechnici() {
  try {
    const response = await fetch('/api/technicians');
    if (!response.ok) throw new Error('HTTP ' + response.status);
    const data = await response.json(); // JSON string → object
    return data;
  } catch (err) {
    console.error('Laden mislukt:', err.message);
    return [];
  }
}

{technicians.map(tech => (
  <TechnicianRow 
    key={tech.id} 
    name={tech.name} 
  />
))}

useEffect(() => {
  const controller = new AbortController();
  
  fetchOrders(controller.signal); // API call

  return () => controller.abort(); // Cleanup: stop fetch als component sluit
}, []); // [] = alleen bij mount

function useToggle(initialValue = false) {
  const [value, setValue] = useState(initialValue);
  const toggle = () => setValue(!value);
  return [value, toggle];
}

// Gebruik in component:
const [isOpen, toggleOpen] = useToggle();

const Panel = ({ title, children }) => (
  <div className="panel">
    <header>{title}</header>
    <div className="content">{children}</div>
  </div>
);

// Gebruik:
<Panel title="Technicus Info">
  <p>Naam: Jonas</p>
  <SkillBadge skill="Koeltechniek" />
</Panel>

// FOUT: orders.push(new)
// GOED:
setOrders([...orders, newOrder]);

const useOrderStore = create((set) => ({
  orders: [],
  addOrder: (order) => set((state) => ({ orders: [...state.orders, order] })),
}));

// Snapping logica
const pixelsPerQuarter = widthOfHour / 4;
const snappedX = Math.round(mouseX / pixelsPerQuarter) * pixelsPerQuarter;

// Voorbeeld: vervang alle technici op een project
const payload = {
  tech_ids: [[6, 0, [102, 105]]] // Magic Tuple syntax
};

# Voertuig opzoeken en stocklocatie uitlezen
vehicle = models.execute_kw(db, uid, password,
  'fleet.vehicle', 'search_read',
  [['driver_id.name', '=', 'Jonas Vermeersch']],
  {'fields': ['name', 'license_plate', 'stock_location_id']}
)[0]

location_id = vehicle['stock_location_id'][0]  # (id, 'WH/Jonas')

# Nu stock ophalen op dat voertuig
quants = models.execute_kw(db, uid, password,
  'stock.quant', 'search_read',
  [['location_id', '=', location_id]],
  {'fields': ['product_id', 'quantity', 'reserved_quantity']}
)

# Min/max regel aanmaken voor Jonas zijn bestelwagen
orderpoint_id = models.execute_kw(db, uid, password,
  'stock.warehouse.orderpoint', 'create', [{
    'name':         'Jonas / Compressorventiel R32',
    'product_id':   product_id,       # id van het product
    'location_id':  vehicle_loc_id,   # voertuiglocatie
    'product_min_qty': 2,              # bij < 2 → aanvullen
    'product_max_qty': 8,              # aanvullen tot 8
    'qty_multiple':    1,
  }]
)
# Scheduler handmatig triggeren (in productie draait dit als cron)
models.execute_kw(db, uid, password,
  'stock.warehouse.orderpoint', 'action_replenish',
  [[orderpoint_id]]
)

# Tags opvragen van alle voertuigen voor constraints check
vehicles = models.execute_kw(db, uid, password,
  'fleet.vehicle', 'search_read',
  [['active', '=', True]],
  {'fields': ['name', 'license_plate', 'tag_ids', 'driver_id']}
)

# Check: heeft voertuig toegang tot LEZ-zone?
def can_enter_lez(vehicle, zone_tag):
  tag_names = [t['name'] for t in vehicle.get('tag_ids', [])]
  return zone_tag in tag_names

# Voertuigen zonder LEZ-Antwerpen tag filteren
lez_ok = [v for v in vehicles if can_enter_lez(v, 'LEZ-Antwerpen')]

# security/ir.model.access.csv
id,name,model_id:id,group_id:id,perm_read,perm_write,perm_create,perm_unlink
access_stock_quant_tech,quant_tech,model_stock_quant,group_technician,1,0,0,0
access_stock_quant_disp,quant_disp,model_stock_quant,group_dispatcher,1,1,1,0

# Record rule in XML: technieker ziet enkel eigen voertuigstock
# <record id="rule_quant_own_vehicle" model="ir.rule">
#   <field name="domain_force">
#     [('location_id.vehicle_id.driver_id.user_id','=',user.id)]
#   </field>
# </record>

# Python: test als een andere gebruiker (sudo voor admin check)
env_jonas = self.env['stock.quant'].with_user(jonas_user)
quants_jonas = env_jonas.search([])  # geeft enkel Jonas zijn quants

# mail.message uitlezen voor een fsm.order
messages = models.execute_kw(db, uid, password,
  'mail.message', 'search_read',
  [[
    ['res_id',    '=', order_id],
    ['model',     '=', 'fsm.order'],
    ['message_type', 'in', ['notification', 'comment']]
  ]],
  {'fields': ['date', 'author_id', 'body', 'tracking_value_ids'],
   'order': 'date asc'}
)
for msg in messages:
  print(msg['date'], msg['author_id'][1], msg['body'][:60])

# Odoo 17: cycle count via stock.quant action_count
quant_ids = models.execute_kw(db, uid, password,
  'stock.quant', 'search',
  [['location_id', '=', vehicle_loc_id]]
)
# Stel getelde hoeveelheid in voor elk quant
for qid in quant_ids:
  models.execute_kw(db, uid, password,
    'stock.quant', 'write',
    [[qid], {'inventory_quantity': getelde_hoeveelheid[qid]}]
  )
# Valideer de telling — dit maakt correctie-moves aan
models.execute_kw(db, uid, password,
  'stock.quant', 'action_apply_inventory',
  [quant_ids]
)

# Dead stock: producten op voertuig zonder beweging > 60 dagen
from datetime import datetime, timedelta
cutoff = (datetime.now() - timedelta(days=60)).strftime('%Y-%m-%d')

# Alle move lines van Jonas zijn voertuig in de afgelopen 60 dagen
recent_moves = models.execute_kw(db, uid, password,
  'stock.move.line', 'search_read',
  [[
    ['location_id', '=', vehicle_loc_id],
    ['date', '>=', cutoff],
    ['state', '=', 'done']
  ]],
  {'fields': ['product_id']}
)
recent_product_ids = {m['product_id'][0] for m in recent_moves}

# Quants waarvan het product NIET in recent bewogen is
all_quants = models.execute_kw(db, uid, password,
  'stock.quant', 'search_read',
  [['location_id', '=', vehicle_loc_id]],
  {'fields': ['product_id', 'quantity']}
)
dead_stock = [q for q in all_quants
              if q['product_id'][0] not in recent_product_ids]

<!-- security/record_rules.xml -->
<record id="rule_fsm_order_technician" model="ir.rule">
  <field name="name">FSM Order: technieker enkel eigen orders</field>
  <field name="model_id" ref="fieldservice.model_fsm_order"/>
  <field name="groups" eval="[(4, ref('dispatch_iq_horeca.group_technician'))]"/>
  <field name="domain_force">
    [('person_id.user_id', '=', user.id)]
  </field>
  <field name="perm_read" eval="True"/>
  <field name="perm_write" eval="True"/>
  <field name="perm_create" eval="False"/>
  <field name="perm_unlink" eval="False"/>
</record>

# Model met volledige tracking
class HorecaEquipment(models.Model):
  _name    = 'horeca.equipment'
  _inherit = ['mail.thread', 'mail.activity.mixin']

  name        = fields.Char(tracking=True)
  state       = fields.Selection([
    ('active',  'Actief'),
    ('defect',  'Defect'),
    ('retired', 'Uitgedienst'),
  ], default='active', tracking=True)
  technician_id = fields.Many2one('fsm.person', tracking=True)

# Handmatige log entry (in Python logic)
equipment.message_post(
  body='Apparaat verplaatst naar ander voertuig wegens noodinterventie.',
  message_type='comment',
  subtype_xmlid='mail.mt_note'
)

# Activity aanmaken op een fsm.order
order.activity_schedule(
  'mail.mail_activity_data_todo',    # activiteitstype
  date_deadline=fields.Date.today() + timedelta(days=2),
  summary='Onderdelen bestellen voor COND-R32',
  note='Leverancier bevestigde levering binnen 48u. Herbevestig datum bij klant.',
  user_id=dispatcher_user.id
)

# Alle vervallen activities voor DispatchIQ opvragen
overdue = env['mail.activity'].search([
  ['res_model', '=', 'fsm.order'],
  ['date_deadline', '<', fields.Date.today()],
  ['user_id', '=', uid]
])

# tests/test_access_roles.py
class TestAccessRoles(TransactionCase):
  def setUp(self):
    super().setUp()
    self.dispatcher = self.env['res.users'].create({
      'name': 'Dispatcher Test', 'login': 'disp_test',
      'groups_id': [(4, self.env.ref('dispatch_iq_horeca.group_dispatcher').id)]
    })
    self.technician = self.env['res.users'].create({
      'name': 'Jonas Test', 'login': 'jonas_test',
      'groups_id': [(4, self.env.ref('dispatch_iq_horeca.group_technician').id)]
    })

  def test_technician_cannot_create_order(self):
    """Technieker mag geen orders aanmaken."""
    with self.assertRaises(AccessError):
      self.env['fsm.order'].with_user(self.technician).create(
        {'name': 'FSM/HACK/1'}
      )

# Veld enkel zichtbaar voor administratie
contract_price = fields.Float(
  'Contractprijs',
  groups='dispatch_iq_horeca.group_admin_invoicing'
)

# XML view: veld verbergen via attrs (UI-niveau, niet security)
# <field name="contract_price"
#        groups="dispatch_iq_horeca.group_admin_invoicing"/>

# ORM test: technieker kan veld niet lezen
equip_as_tech = self.env['horeca.equipment'].with_user(tech_user)
# contract_price geeft False (niet 0.0) als het veld afgeschermd is
assert equip_as_tech.browse(equip_id).contract_price == False

# Audit export: alle fsm.order wijzigingen van afgelopen maand
from datetime import datetime, timedelta
cutoff = (datetime.now() - timedelta(days=30)).strftime('%Y-%m-%d %H:%M:%S')

messages = models.execute_kw(db, uid, pw,
  'mail.message', 'search_read',
  [[
    ['model',   '=', 'fsm.order'],
    ['date',    '>=', cutoff],
    ['tracking_value_ids', '!=', False]
  ]],
  {'fields': ['date', 'author_id', 'res_id', 'tracking_value_ids']}
)
# Schrijf als CSV naar audit bestand
import csv
with open('audit_export.csv', 'w') as f:
  writer = csv.DictWriter(f, fieldnames=['date', 'author', 'order_id', 'changes'])
  writer.writeheader()
  for m in messages:
    writer.writerow({'date': m['date'], 'author': m['author_id'][1],
                     'order_id': m['res_id'], 'changes': m['tracking_value_ids']})

# Incident response: gebruiker onmiddellijk blokkeren
suspicious_user_id = 42
models.execute_kw(db, admin_uid, admin_pw,
  'res.users', 'write',
  [[suspicious_user_id], {'active': False}]
)

# Forensiek: alle acties van die gebruiker reconstructen
messages = models.execute_kw(db, admin_uid, admin_pw,
  'mail.message', 'search_read',
  [['author_id.user_ids', '=', suspicious_user_id]],
  {'fields': ['date', 'model', 'res_id', 'body'],
   'order': 'date desc', 'limit': 200}
)
for m in messages:
  print(m['date'], m['model'], '#' + str(m['res_id']))

# __manifest__.py van fieldservice_stock lezen
# Vind je op: OCA/field-service/fieldservice_stock/__manifest__.py
{
  'name': 'Field Service - Stock',
  'version': '17.0.1.0.0',
  'depends': [
    'fieldservice',           # OCA fieldservice basis
    'stock',                   # Odoo core inventory
    'stock_picking_type_charge', # OCA stock module
  ],
  'external_dependencies': {
    'python': [],              # geen extra pip packages nodig
  },
  'data': [
    'security/ir.model.access.csv',
    'views/fsm_order_views.xml',
    'views/stock_picking_views.xml',
  ]
}

# docker-compose.yml extra-addons volume
services:
  odoo:
    image: odoo:17.0
    volumes:
      - ./extra-addons:/mnt/extra-addons
    environment:
      - HOST=db
    command: odoo --addons-path=/usr/lib/python3/dist-packages/odoo/addons,/mnt/extra-addons

# Shell: OCA modules clonen naar extra-addons
cd /mnt/extra-addons
git clone -b 17.0 --depth=1 https://github.com/OCA/field-service.git OCA-field-service
git clone -b 17.0 --depth=1 https://github.com/OCA/fleet.git OCA-fleet

# Symlinks zodat Odoo de individuele modules vindt
for mod in OCA-field-service/fieldservice OCA-field-service/fieldservice_stock; do
  ln -sf /mnt/extra-addons/$mod /mnt/extra-addons/$(basename $mod)
done

# Volledige __manifest__.py voor dispatch_iq_horeca
{
  'name':        'DispatchIQ Horeca',
  'version':     '17.0.1.0.0',
  'summary':     'Horeca field service extensies voor DispatchIQ',
  'description': """Voegt horeca.equipment model, werkbon PDF en skills
    constraint check toe aan de OCA fieldservice module.""",
  'author':      'TechniCool NV',
  'website':     'https://dispatchiq.be',
  'license':     'LGPL-3',
  'category':    'Field Service',
  'depends': ['fieldservice', 'fieldservice_stock', 'mail', 'fleet'],
  'external_dependencies': {'python': ['vobject']}, # pip install vobject
  'data': [
    'security/groups.xml',
    'security/ir.model.access.csv',
    'views/horeca_equipment_views.xml',
    'report/werkbon_template.xml',
  ],
  'demo': ['demo/demo_data.xml'],
  'installable': True,
  'auto_install': False,
}

# Structuur van fieldservice module (vereenvoudigd)
fieldservice/
├── __init__.py
├── __manifest__.py
├── models/
│   ├── __init__.py
│   ├── fsm_order.py        # het hoofdmodel
│   ├── fsm_location.py     # klantlocaties
│   ├── fsm_person.py       # techniekers
│   └── fsm_stage.py        # order stages
├── views/
│   ├── fsm_order_views.xml # form, list, kanban van orders
│   └── menus.xml           # navigatiemenu structuur
├── security/
│   ├── groups.xml
│   └── ir.model.access.csv
├── data/
│   └── fsm_stage_data.xml  # standaard stages
└── tests/
    └── test_fsm_order.py

# Controleer welke branch je nodig hebt
# Regel: branch = je Odoo versie, altijd

# Goed: 17.0 Odoo met 17.0 OCA modules
git clone -b 17.0 https://github.com/OCA/field-service.git

# FOUT: 17.0 Odoo met 16.0 OCA modules
# git clone -b 16.0 https://github.com/OCA/field-service.git
# → ImportError, XML parse errors, missing columns

# Controleer versie in manifest na clone:
import ast
with open('fieldservice/__manifest__.py') as f:
  manifest = ast.literal_eval(f.read())
print(manifest['version'])  # '17.0.x.x.x' — eerste deel = Odoo versie

# Optie 1: pin op een specifieke commit hash
git clone https://github.com/OCA/field-service.git OCA-field-service
cd OCA-field-service
git checkout a3f7c2d  # specifieke commit — voor altijd reproduceerbaar

# Optie 2: pin op een release tag (als die beschikbaar is)
git checkout tags/17.0.1.0.0

# Optie 3: git submodule in je project repo
# .gitmodules:
# [submodule "OCA-field-service"]
#     path = extra-addons/OCA-field-service
#     url = https://github.com/OCA/field-service.git
#     branch = 17.0

# Bewaar de gebruikte commit in een lockfile
echo "OCA-field-service: $(git -C OCA-field-service rev-parse HEAD)" >> oca_versions.lock

# Upgrade rehearsal stappenplan (bash)

# 1. Productie DB dump naar staging
docker exec -t odoo_db pg_dump -U odoo technicool_prod | \
  docker exec -i staging_db psql -U odoo technicool_staging

# 2. OCA module updaten op staging server
cd extra-addons/OCA-field-service
git fetch origin
git log HEAD..origin/17.0 --oneline   # bekijk wat er veranderd is
git pull origin 17.0

# 3. Module updaten in Odoo staging
docker exec odoo_staging odoo -d technicool_staging \
  -u fieldservice_stock --stop-after-init \
  --log-level=info 2>&1 | tee upgrade_log.txt

# 4. Controleer op errors in logbestand
grep -i "ERROR\|CRITICAL\|Traceback" upgrade_log.txt

# Horeca stages aanmaken via XML data file
<!-- data/fsm_stage_data.xml -->
<record id="stage_new"        model="fsm.stage"><field name="name">Nieuw</field>         <field name="sequence">1</field></record>
<record id="stage_planned"     model="fsm.stage"><field name="name">Ingepland</field>     <field name="sequence">2</field></record>
<record id="stage_traveling"   model="fsm.stage"><field name="name">Onderweg</field>      <field name="sequence">3</field></record>
<record id="stage_waiting"     model="fsm.stage"><field name="name">Wacht op stock</field><field name="sequence">4</field></record>
<record id="stage_done"        model="fsm.stage">
  <field name="name">Afgerond</field>
  <field name="sequence">10</field>
  <field name="is_closed" eval="True"/>  <!-- order is afgesloten -->
</record>

# Benodigde onderdelen toevoegen aan een fsm.order
# product_ids is een Many2many naar fsm.order.line (niet rechtstreeks product)
order_line_ids = models.execute_kw(db, uid, pw,
  'fsm.order.product', 'search_read',
  [['order_id', '=', order_id]],
  {'fields': ['product_id', 'product_uom_qty', 'qty_done']}
)
# Geeft bv: [{'product_id': [42,'COND-R32'], 'product_uom_qty': 1.0, 'qty_done': 0.0}]

# Stock picking die aangemaakt werd bij afsluiten
picking = models.execute_kw(db, uid, pw,
  'stock.picking', 'search_read',
  [['fsm_order_id', '=', order_id]],
  {'fields': ['name', 'state', 'move_ids']}
)

# Automated action: bij stock ontvangst herstelorder herplannen
<!-- In data/automated_actions.xml -->
<record id="action_replan_on_stock" model="base.automation">
  <field name="model_id" ref="stock.model_stock_move"/>
  <field name="trigger">on_write</field>
  <field name="filter_pre_domain">[('state','!=','done')]</field>
  <field name="filter_domain">[('state','=','done')]</field>
  <field name="action_server_id">
    <record model="ir.actions.server">
      <field name="state">code</field>
      <field name="code">
for move in records:
  orders = env['fsm.order'].search([
    ('stage_id.name','=','Wacht op stock'),
    ('product_ids.product_id','=',move.product_id.id)
  ])
  planned = env.ref('dispatch_iq_horeca.stage_planned')
  orders.write({'stage_id': planned.id})</field>
    </record>
  </field>
</record>

# Template aanmaken via XML-RPC
template_id = models.execute_kw(db, uid, pw,
  'fsm.template', 'create', [{
    'name': 'Combi-steamer preventief onderhoud',
    'checklist_ids': [
      (0, 0, {'name': 'Stoomgenerator ontkalken'}),
      (0, 0, {'name': 'Dichtingen controleren'}),
      (0, 0, {'name': 'Temperatuurkalibratie uitvoeren'}),
      (0, 0, {'name': 'Reinigingsprogramma doorlopen'}),
    ]
  }]
)
# Koppelen aan een order
models.execute_kw(db, uid, pw,
  'fsm.order', 'write',
  [[order_id], {'template_id': template_id}]
)

// Node.js: volledige parts check implementatie
async function partsCheck(orderId, techId) {
  // Stap 1: benodigde onderdelen van de order
  const lines = await odoo.searchRead('fsm.order.product',
    [['order_id', '=', orderId]],
    ['product_id', 'product_uom_qty']
  );
  // Stap 2: voertuiglocatie van de technieker
  const [vehicle] = await odoo.searchRead('fleet.vehicle',
    [['driver_id.user_id', '=', techId]],
    ['stock_location_id']
  );
  const locId = vehicle.stock_location_id[0];
  // Stap 3: check stock per product
  const missing = [];
  for (const line of lines) {
    const [quant] = await odoo.searchRead('stock.quant',
      [['product_id', '=', line.product_id[0]],['location_id','=',locId]],
      ['quantity']
    );
    const available = quant ? quant.quantity : 0;
    if (available < line.product_uom_qty)
      missing.push({ product: line.product_id[1], needed: line.product_uom_qty, available });
  }
  return { ok: missing.length === 0, missing };
}

# Lifecycle constraint: order afsluiten
@api.constrains('stage_id')
def _check_close_conditions(self):
  for order in self:
    if not order.stage_id.is_closed:
      continue
    if order.force_close:  # dispatcher override
      continue
    # Checklist volledig?
    open_items = order.checklist_ids.filtered(lambda c: not c.is_done)
    if open_items:
      raise ValidationError(
        f'Sluit eerst alle checklist items af: {", ".join(open_items.mapped("name"))}'
      )
    # Handtekening aanwezig?
    if not order.signature:
      raise ValidationError('Klanthandtekening verplicht voor afsluiting.')

// API proxy: datacontract voor fsm.order
function mapOrder(raw) {
  return {
    id:            raw.id,
    reference:     raw.name        || '',
    client:        raw.partner_id  ? raw.partner_id[1] : null,
    clientId:      raw.partner_id  ? raw.partner_id[0] : null,
    technicianId:  raw.person_id   ? raw.person_id[0]  : null,
    technician:    raw.person_id   ? raw.person_id[1]  : null,
    start:         raw.scheduled_date_start || null,
    end:           raw.scheduled_date_end   || null,
    stage:         raw.stage_id    ? raw.stage_id[1]   : null,
    isClosed:      raw.stage_id?.is_closed  || false,
    priority:      raw.priority    || '0',
    products:      (raw.product_ids || []).map(p => p[0]),
  };
}

# Effectieve beschikbaarheid op voertuig van Jonas
quants = models.execute_kw(db, uid, pw,
  'stock.quant', 'search_read',
  [['location_id', '=', vehicle_loc_id]],
  {'fields': ['product_id', 'quantity', 'reserved_quantity']}
)
# Beschikbaarheid berekenen
stock_map = {}
for q in quants:
  pid = q['product_id'][0]
  available = q['quantity'] - q['reserved_quantity']
  stock_map[pid] = available  # product_id → beschikbare qty

# Check of product X beschikbaar is in qty Y
def has_stock(product_id, needed_qty):
  return stock_map.get(product_id, 0) >= needed_qty

// React: constraint dialoog bij Gantt drag
async function handleDrop(orderId, techId, newSlot) {
  const check = await fetch(
    `/api/constraints/parts?orderId=${orderId}&techId=${techId}`
  ).then(r => r.json());

  if (!check.ok) {
    const confirmed = await showConstraintDialog({
      title:   'Ontbrekende onderdelen',
      missing: check.missing,       // [{product, needed, available}]
      message: 'Wil je toch inplannen?',
    });
    if (!confirmed) return;  // dispatcher annuleert
  }
  // Doorgaan met toewijzing
  await assignOrder(orderId, techId, newSlot);
}

// Node.js: herstelorder aanmaken vanuit vaststelling
async function createRepairOrder(vaststellingId, missingParts) {
  const source = await odoo.read('fsm.order', [vaststellingId],
    ['partner_id', 'location_id', 'person_id', 'name']);

  const repairId = await odoo.create('fsm.order', {
    name:        source.name + '/HERSTEL',
    partner_id:  source.partner_id[0],
    location_id: source.location_id[0],
    person_id:   source.person_id[0],
    type:        'herstel',
    stage_id:    STAGE_WACHT_OP_STOCK,
    origin:      vaststellingId,
    product_ids: missingParts.map(p => [0, 0, {
      product_id: p.productId, product_uom_qty: p.needed
    }]),
  });
  return repairId;
}

# Reservaties vrijgeven bij order-annulatie
def action_cancel(self):
  for order in self:
    # Annuleer alle open pickings voor deze order
    pickings = self.env['stock.picking'].search([
      ('fsm_order_id', '=', order.id),
      ('state', 'not in', ['done', 'cancel'])
    ])
    pickings.action_cancel()  # geeft reservaties vrij
    # Zet order op geannuleerde stage
    order.stage_id = self.env.ref('dispatch_iq_horeca.stage_cancelled')
  return True

# Check reservatie status via API
picking = search_read('stock.picking',
  [['fsm_order_id', '=', order_id], ['state', '!=', 'cancel']],
  ['state', 'move_ids']
)

// TypeScript schema voor parts-check response
interface PartsCheckResult {
  ok:        boolean;
  orderId:   number;
  techId:    number;
  missing:   PartsCheckItem[];   // altijd array, nooit null
  available: PartsCheckItem[];
}

interface PartsCheckItem {
  product:      string;           // display naam
  productCode:  string;           // internal reference
  qtyNeeded:    number;
  qtyAvailable: number;
}

// Zod validatie in de Express middleware
import { z } from 'zod';
const PartsCheckSchema = z.object({
  ok:        z.boolean(),
  orderId:   z.number(),
  techId:    z.number(),
  missing:   z.array(z.object({ product: z.string(), qtyNeeded: z.number(), qtyAvailable: z.number() })),
  available: z.array(z.object({ product: z.string(), qtyNeeded: z.number(), qtyAvailable: z.number() })),
});

// Uitgebreide parts check met partial availability
async function partsCheckDetailed(orderId, techId) {
  const [lines, stockMap] = await Promise.all([
    getOrderLines(orderId),
    getVehicleStock(techId),
  ]);

  const missing   = [];
  const available = [];
  let   partial   = false;

  for (const line of lines) {
    const avail = stockMap[line.product_id] ?? 0;
    const item  = { product: line.product_name, needed: line.qty, available: avail };

    if (avail >= line.qty)       available.push(item);
    else if (avail > 0)          { missing.push(item); partial = true; }
    else                         missing.push(item);
  }

  return {
    ok: missing.length === 0,
    partial,          // true als deels beschikbaar
    missing, available,
    score: available.length / lines.length, // 0.0–1.0
  };
}

# Retour picking aanmaken via Python (in module)
def create_return_picking(self, unused_lines):
  """
  unused_lines: [{product_id, qty_returned}]
  Maakt interne transfer aan: Klantlocatie → Voertuig
  """
  vehicle_loc = self.person_id.vehicle_id.stock_location_id
  return self.env['stock.picking'].create({
    'picking_type_id': self.env.ref('stock.picking_type_internal').id,
    'location_id':      self.location_id.stock_location_id.id,
    'location_dest_id': vehicle_loc.id,
    'origin':          self.name + '/RETOUR',
    'move_ids': [(0, 0, {
      'product_id':       line['product_id'],
      'product_uom_qty':  line['qty_returned'],
      'name':             'Retour niet-gebruikt',
      'location_id':      self.location_id.stock_location_id.id,
      'location_dest_id': vehicle_loc.id,
    }) for line in unused_lines]
  })

// Node.js cron: dagelijkse agreement check (elke ochtend 06:00)
import cron from 'node-cron';

cron.schedule('0 6 * * *', async () => {
  const today = new Date().toISOString().slice(0, 10);
  const due = await odoo.searchRead(
    'fieldservice.agreement',
    [['active', '=', true], ['next_date', '<=', today]],
    ['id', 'name', 'next_date']
  );
  console.log(`${due.length} agreements te verwerken`);
  for (const ag of due) {
    await odoo.execute('fieldservice.agreement',
      'action_generate_orders', [[ag.id]]);
    console.log(`✓ ${ag.name} → order aangemaakt`);
  }
});

# Custom SLA velden op fieldservice.agreement (via inheritance)
class DispatchAgreement(models.Model):
  _inherit = 'fieldservice.agreement'

  sla_response_hours = fields.Integer('Max. responstijd (uren)', default=24)
  sla_priority = fields.Selection([
    ('0', 'Standaard'),
    ('1', 'Urgent'),
    ('2', 'Kritisch 24/7'),
  ], default='0')

  def action_generate_orders(self):
    orders = super().action_generate_orders()
    # Kopieer SLA naar gegenereerde orders
    for order in orders:
      order.write({
        'priority': self.sla_priority,
        'sla_deadline': fields.Datetime.now() + timedelta(hours=self.sla_response_hours)
      })
    return orders

# Alle equipment op een locatie opvragen voor bundeling
equipment_on_site = models.execute_kw(db, uid, pw,
  'horeca.equipment', 'search_read',
  [['location_id', '=', hotel_location_id],
   ['state',       '=', 'active']],
  {'fields': ['name', 'brand', 'refrigerant', 'serial_no']}
)
print(f'{len(equipment_on_site)} toestellen op locatie Hotel Metropool')

# Gebundelde order: alle equipment_ids meesturen
bundled_order_id = models.execute_kw(db, uid, pw,
  'fsm.order', 'create', [{
    'name':         'Hotel Metropool — Site visit Q1',
    'location_id':  hotel_location_id,
    'equipment_ids': [(6, 0, [e['id'] for e in equipment_on_site])],
  }]
)

<!-- data/mail_templates.xml -->
<record id="template_order_confirmed" model="mail.template">
  <field name="name">FSM: Interventie bevestigd</field>
  <field name="model_id" ref="fieldservice.model_fsm_order"/>
  <field name="subject">Uw onderhoud op ${object.scheduled_date_start}</field>
  <field name="body_html" type="html">
    <p>Geachte ${object.partner_id.name},</p>
    <p>Onze technieker <strong>${object.person_id.name}</strong>
       komt op <strong>${format_date(object.scheduled_date_start)}</strong>.</p>
    <p>Referentie: ${object.name}</p>
  </field>
  <field name="email_to">${object.partner_id.email}</field>
</record>

// Node.js: agreements rapport
async function agreementsReport() {
  const today = new Date().toISOString().slice(0,10);
  const in60days = new Date(Date.now() + 60 * 86400000).toISOString().slice(0,10);

  const [active, expiringSoon, expired] = await Promise.all([
    odoo.searchRead('fieldservice.agreement',
      [['active','=',true],['end_date','>',today]],
      ['name','partner_id','end_date','next_date']),
    odoo.searchRead('fieldservice.agreement',
      [['end_date','<=',in60days],['end_date','>',today]],
      ['name','partner_id','end_date']),
    odoo.searchRead('fieldservice.agreement',
      [['end_date','<=',today]],
      ['name','partner_id','end_date']),
  ]);
  return { active: active.length, expiringSoon, expired: expired.length };
}

# Seizoensaanpassing: vermijd zomer (juli-aug) voor keukenwerk
from datetime import date, timedelta

def adjust_for_season(next_date, category):
  if category != 'kitchen':
    return next_date
  # Zomerperiode = juli (7) en augustus (8)
  if next_date.month in (7, 8):
    # Schuif op naar 1 september van hetzelfde jaar
    return date(next_date.year, 9, 1)
  return next_date

# Omgekeerd: koelinstallaties EXTRA in zomer
def cooling_season_extra(agreement):
  today = date.today()
  if today.month == 6 and agreement.category == 'cooling':
    # Voeg extra check in in juli toe
    return date(today.year, 7, 15)
  return agreement.next_date

# Capaciteitscheck voor ordergeneratie
def get_first_available_date(env, from_date, max_per_day=8):
  """Zoek eerste dag na from_date met minder dan max_per_day orders."""
  check_date = from_date
  for _ in range(30):  # max 30 dagen vooruit zoeken
    count = env['fsm.order'].search_count([
      ('scheduled_date_start', '>=', check_date.strftime('%Y-%m-%d 00:00:00')),
      ('scheduled_date_start', '<',  check_date.strftime('%Y-%m-%d 23:59:59')),
      ('stage_id.is_closed',    '=',  False),
    ])
    if count < max_per_day:
      return check_date
    check_date += timedelta(days=1)
    if check_date.weekday() >= 5:  # overslaan weekend
      check_date += timedelta(days=7 - check_date.weekday())
  return None  # geen vrije dag gevonden binnen 30 dagen

<!-- Trigger: stage wijzigt naar "Wacht op stock" -->
<record id="auto_waiting_for_stock" model="base.automation">
  <field name="name">Order → Wacht op stock: notificeer dispatcher</field>
  <field name="model_id" ref="fieldservice.model_fsm_order"/>
  <field name="trigger">on_write</field>
  <field name="filter_pre_domain">  <!-- vóór schrijven: NIET op wacht -->
    [('stage_id.name','!=','Wacht op stock')]
  </field>
  <field name="filter_domain">       <!-- ná schrijven: WEL op wacht -->
    [('stage_id.name','=','Wacht op stock')]
  </field>
  <field name="action_server_id" ref="action_notify_dispatcher_stock"/>
</record>

<!-- data/crons.xml -->
<record id="cron_daily_replenishment_check" model="ir.cron">
  <field name="name">DispatchIQ: Dagelijkse aanvulcheck voertuigen</field>
  <field name="model_id" ref="stock.model_stock_warehouse_orderpoint"/>
  <field name="state">code</field>
  <field name="code">
orderpoints = env['stock.warehouse.orderpoint'].search([
  ('location_id.usage','=','internal'),
  ('location_id.name','ilike','VEH/')  # enkel voertuiglocaties
])
orderpoints.action_replenish()
env['ir.logging'].sudo().create({'name':'DispatchIQ Cron',
  'type':'server','message':f'{len(orderpoints)} voertuigen gecontroleerd',
  'path':'cron_replenishment','func':'run','line':1,'level':'info'})
  </field>
  <field name="interval_number">1</field>
  <field name="interval_type">days</field>
  <field name="numbercall">-1</field>
  <field name="active" eval="True"/>
</record>

# Server action code: template verzenden
for record in records:
  # Stuur bevestiging naar klant
  template = env.ref('dispatch_iq_horeca.template_order_confirmed')
  template.send_mail(record.id, force_send=True)

# Reminder: on_time trigger 24u voor scheduled_date_start
<!-- In de automated action -->
<field name="trigger">on_time</field>
<field name="trg_date_id" ref="fieldservice.field_fsm_order__scheduled_date_start"/>
<field name="trg_date_range">-24</field>   <!-- 24u VOOR de datum -->
<field name="trg_date_range_type">hours</field>

// Node.js: retry met exponentieel backoff
async function withRetry(fn, maxAttempts = 3) {
  let lastError;
  for (let attempt = 1; attempt <= maxAttempts; attempt++) {
    try {
      return await fn();
    } catch (err) {
      lastError = err;
      if (attempt < maxAttempts) {
        const delay = Math.pow(2, attempt) * 1000; // 2s, 4s, 8s
        console.warn(`Poging ${attempt} mislukt, retry na ${delay}ms`, err.message);
        await new Promise(r => setTimeout(r, delay));
      }
    }
  }
  throw lastError;
}

// Gebruik:
const orders = await withRetry(() => odoo.searchRead('fsm.order', ...));

// Node.js health monitor: check Odoo cron resultaten
async function checkCronHealth() {
  const oneHourAgo = new Date(Date.now() - 3600000).toISOString().replace('T', ' ').slice(0,19);
  const failures = await odoo.searchRead('ir.logging', [
    ['level',       'in', ['ERROR', 'CRITICAL']],
    ['create_date', '>=', oneHourAgo],
    ['name',        'ilike', 'DispatchIQ'],
  ], ['name', 'message', 'create_date']);

  if (failures.length > 0) {
    await sendAlert(`⚠ ${failures.length} DispatchIQ cron errors laatste uur`,
      failures.map(f => `${f.create_date}: ${f.message}`).join('\n'));
  }
  return { healthy: failures.length === 0, failures };
}

// Node.js: idempotency check voor ordercreatie
const crypto = require('crypto');

function makeKey(orderId, action, date) {
  return crypto.createHash('sha256')
    .update(`${orderId}-${action}-${date}`)
    .digest('hex')
    .slice(0, 32);
}

async function idempotentCreate(orderId, action, createFn) {
  const key = makeKey(orderId, action, new Date().toISOString().slice(0, 10));
  const existing = await db.get('SELECT id FROM processed_actions WHERE key=?', [key]);
  if (existing) {
    console.log(`Idempotency hit: ${key} — skip`);
    return { skipped: true, key };
  }
  const result = await createFn();
  await db.run('INSERT INTO processed_actions(key,result) VALUES(?,?)',
    [key, JSON.stringify(result)]);
  return result;
}

# Python: dead-letter opvang in server action
def safe_execute_action(env, record, action_fn):
  try:
    action_fn(record)
  except Exception as e:
    # Bewaar in dead-letter tabel
    existing = env['dispatch.failed.action'].search([
      ('record_model', '=', record._name),
      ('record_id',    '=', record.id),
      ('action',       '=', action_fn.__name__),
    ], limit=1)
    if existing:
      existing.write({'retry_count': existing.retry_count + 1,
                      'last_error': str(e)})
    else:
      env['dispatch.failed.action'].create({
        'record_model': record._name, 'record_id': record.id,
        'action': action_fn.__name__, 'last_error': str(e),
        'retry_count': 1,
      })

<!-- views/fsm_order_horeca_views.xml -->
<record id="view_fsm_order_form_horeca_ext" model="ir.ui.view">
  <field name="inherit_id" ref="fieldservice.view_fsm_order_form"/>
  <field name="arch" type="xml">
    <xpath expr="//notebook" position="inside">
      <page string="Horeca details">
        <group string="Koeltechniek">
          <field name="refrigerant_type"/>
          <field name="equipment_id"/>  <!-- horeca.equipment -->
        </group>
        <group string="Toegang">
          <field name="location_id.lez_zone" readonly="1"/>
          <field name="location_id.site_access_required" readonly="1"/>
        </group>
      </page>
    </xpath>
  </field>
</record>

// src/adapters/IDispatchAdapter.js
class IDispatchAdapter {
  async checkParts(orderId, techId)   { throw new Error('Not implemented'); }
  async checkSkills(orderId, techId)  { throw new Error('Not implemented'); }
  async checkAccess(orderId, techId)  { throw new Error('Not implemented'); }
  async checkZone(orderId, vehicleId) { throw new Error('Not implemented'); }
  async checkAll(orderId, techId, vehicleId) {
    const [parts, skills, access, zone] = await Promise.all([
      this.checkParts(orderId, techId),
      this.checkSkills(orderId, techId),
      this.checkAccess(orderId, techId),
      this.checkZone(orderId, vehicleId),
    ]);
    return { ok: parts.ok && skills.ok && access.ok && zone.ok,
              parts, skills, access, zone };
  }
}

// OdooAdapter.checkSkills implementatie
async checkSkills(orderId, techId) {
  const [order, tech] = await Promise.all([
    odoo.read('fsm.order', [orderId], ['skill_ids', 'refrigerant_type']),
    odoo.read('fsm.person', [techId],  ['skill_ids']),
  ]);
  const required = new Set(order.skill_ids);
  const has      = new Set(tech.skill_ids);
  const missing  = [...required].filter(s => !has.has(s));
  if (order.refrigerant_type === 'R32' && !tech.skill_ids.includes('R32_CERT'))
    missing.push('R32-certificaat (F-gas)');
  return { ok: missing.length === 0, missing };
}

// Uniforme ConstraintResult wrapper
function constraintResult(type, ok, details, severity = 'warn') {
  return { ok, type, severity, details };
}

// Gebruik in alle check methods:
async checkZone(orderId, vehicleId) {
  // ... zone check logica ...
  if (!hasTag) return constraintResult('zone', false,
    { zone: lez, vehicle: vehicleId }, 'block');  // HARD block
  return constraintResult('zone', true, {});
}

async checkParts(orderId, techId) {
  // ... parts check ...
  if (missing.length) return constraintResult('parts', false,
    { missing }, 'warn');   // SOFT warn — dispatcher mag overschrijven
  return constraintResult('parts', true, {});
}

// Demo dataset script — uitvoeren vóór de presentatie
const DEMO_SCENARIOS = [
  { orderId: 1, techId: 1, expected: 'OK',            desc: 'Alles correct' },
  { orderId: 2, techId: 2, expected: 'WARN_PARTS',   desc: 'Parts tekort' },
  { orderId: 3, techId: 3, expected: 'BLOCK_SKILLS', desc: 'R32 certificaat ontbreekt' },
  { orderId: 4, techId: 1, expected: 'BLOCK_ZONE',   desc: 'Voertuig mag LEZ Antwerpen niet in' },
];

for (const s of DEMO_SCENARIOS) {
  const result = await adapter.checkAll(s.orderId, s.techId, s.vehicleId);
  console.log(`${s.desc}: ok=${result.ok}`,
    result.ok ? '✅' : `❌ ${JSON.stringify(result)}`);
}

// API v1 (bestaand) — alle consumers kennen dit
// GET /api/v1/constraints/check → { ok, parts, skills }

// API v2 (uitbreiding) — voegt access en zone toe
// GET /api/v2/constraints/check → { ok, parts, skills, access, zone }

// Express router versioning
const v1 = express.Router();
const v2 = express.Router();

v1.get('/constraints/check', async (req, res) => {
  const { orderId, techId } = req.query;
  const result = await adapter.checkAll(orderId, techId);
  res.json({ ok: result.ok, parts: result.parts, skills: result.skills });  // v1: enkel 2 checks
});

v2.get('/constraints/check', async (req, res) => {
  const { orderId, techId, vehicleId } = req.query;
  const result = await adapter.checkAll(orderId, techId, vehicleId);
  res.json(result);  // v2: alle 4 checks
});

app.use('/api/v1', v1);
app.use('/api/v2', v2);

// Observability middleware voor constraints
import { randomUUID } from 'crypto';

function withObservability(checkFn, type) {
  return async (...args) => {
    const traceId = randomUUID();
    const start = Date.now();
    try {
      const result = await checkFn(...args);
      const ms = Date.now() - start;
      logger.info({ traceId, type, ms, ok: result.ok }, 'constraint check');
      metrics.histogram(`constraint_latency_ms`, ms, { type });
      return { ...result, traceId };
    } catch (err) {
      logger.error({ traceId, type, error: err.message }, 'constraint failed');
      metrics.increment('constraint_error_total', { type });
      throw err;
    }
  };
}

# Volledige __manifest__.py met alle praktische velden
{
  'name':          'DispatchIQ Horeca',
  'version':       '17.0.1.0.0',     # altijd Odoo-versie als prefix
  'summary':       'Horeca field service module voor DispatchIQ',
  'author':        'TechniCool NV',
  'website':       'https://dispatchiq.be',
  'license':       'LGPL-3',
  'category':      'Field Service',
  'depends': ['fieldservice', 'fieldservice_stock', 'fleet', 'mail'],
  'data': [
    'security/groups.xml',                  # 1. groepen eerst
    'security/ir.model.access.csv',         # 2. dan toegangsrechten
    'views/horeca_equipment_views.xml',      # 3. views
    'views/fsm_order_horeca_views.xml',
    'report/werkbon_template.xml',           # 4. rapporten
    'data/fsm_stage_data.xml',               # 5. initiële data
    'data/automated_actions.xml',            # 6. automaties als laatste
  ],
  'demo': ['demo/demo_horeca.xml'],         # optioneel: testdata
  'installable':   True,
  'auto_install':  False,
}

# models/horeca_equipment.py
from odoo import models, fields, api
from odoo.exceptions import ValidationError
import logging
_logger = logging.getLogger(__name__)

class HorecaEquipment(models.Model):
  _name        = 'horeca.equipment'
  _description = 'Horeca Apparatuur'
  _inherit     = ['mail.thread', 'mail.activity.mixin']
  _order       = 'name asc'   # standaard sortering
  _rec_name    = 'name'        # welk veld gebruikt wordt als display naam

  name         = fields.Char('Naam', required=True, tracking=True)
  serial_no    = fields.Char('Serienummer', tracking=True)
  brand        = fields.Selection([
    ('rational',   'Rational'),
    ('electrolux', 'Electrolux'),
    ('mkn',        'MKN'),
    ('other',      'Andere'),
  ], string='Merk', required=True)
  location_id  = fields.Many2one('fsm.location', 'Locatie', ondelete='set null')
  state        = fields.Selection([
    ('active', 'Actief'), ('defect', 'Defect'), ('retired', 'Uitgedienst')
  ], default='active', tracking=True)

# Alle veldtypes in context van horeca.equipment
class HorecaEquipment(models.Model):
  _name = 'horeca.equipment'

  name          = fields.Char('Naam', size=128)        # varchar(128)
  notes         = fields.Text('Notities')               # text, geen limiet
  year          = fields.Integer('Bouwjaar')            # integer
  voltage       = fields.Float('Voltage', digits=(6,1)) # 6 cijfers, 1 decimaal
  in_service    = fields.Boolean('In dienst', default=True)
  install_date  = fields.Date('Installatiedatum')
  last_service  = fields.Datetime('Laatste onderhoud')
  photo         = fields.Binary('Foto', attachment=True) # opgeslagen als ir.attachment
  brand         = fields.Selection([('rational','Rational'),...])
  location_id   = fields.Many2one('fsm.location')        # FK → 1 locatie
  service_ids   = fields.One2many('fsm.order','equipment_id') # inverse FK
  skill_ids     = fields.Many2many('dispatch.skill')     # M2M → meerdere skills
  description   = fields.Html('Beschrijving')           # rich text (WYSIWYG)

# Computed fields op horeca.equipment
service_count  = fields.Integer(
  compute='_compute_service_count', store=True)
last_service   = fields.Datetime(
  compute='_compute_last_service', store=True)
age_years      = fields.Float(
  compute='_compute_age', store=False)  # altijd vers berekend

@api.depends('service_ids')
def _compute_service_count(self):
  for rec in self:
    rec.service_count = len(rec.service_ids)

@api.depends('service_ids.scheduled_date_start')
def _compute_last_service(self):
  for rec in self:
    done = rec.service_ids.filtered(lambda s: s.stage_id.is_closed)
    rec.last_service = max(done.mapped('scheduled_date_start'), default=False)

@api.depends('install_date')
def _compute_age(self):
  for rec in self:
    if rec.install_date:
      rec.age_years = (fields.Date.today() - rec.install_date).days / 365.25
    else:
      rec.age_years = 0.0

# Python constraint + SQL constraint op horeca.equipment
class HorecaEquipment(models.Model):
  _name = 'horeca.equipment'

  # SQL constraint: serienummer uniek per bedrijf
  _sql_constraints = [
    ('unique_serial', 'UNIQUE(serial_no, company_id)',
     'Serienummer moet uniek zijn binnen het bedrijf.'),
  ]

  @api.constrains('serial_no')
  def _check_serial_length(self):
    for rec in self:
      if rec.serial_no and len(rec.serial_no) < 5:
        raise ValidationError(
          f'Serienummer "{rec.serial_no}" is te kort. Minimum 5 tekens vereist.'
        )

  @api.constrains('install_date')
  def _check_install_date(self):
    for rec in self:
      if rec.install_date and rec.install_date > fields.Date.today():
        raise ValidationError('Installatiedatum kan niet in de toekomst liggen.')

# CRUD overrides op horeca.equipment
@api.model
def create(self, vals):
  # Genereer interne code als niet meegegeven
  if not vals.get('internal_code'):
    seq = self.env['ir.sequence'].next_by_code('horeca.equipment.seq')
    vals['internal_code'] = seq
  record = super().create(vals)
  _logger.info(f'HorecaEquipment aangemaakt: {record.name} ({record.internal_code})')
  return record

def write(self, vals):
  # Als state naar 'retired' gaat: log dit
  if vals.get('state') == 'retired':
    for rec in self:
      rec.message_post(body=f'Apparaat {rec.name} buiten dienst gesteld.')
  return super().write(vals)

def unlink(self):
  # Verhinder verwijdering van apparaten met openstaande orders
  for rec in self:
    if rec.service_ids.filtered(lambda o: not o.stage_id.is_closed):
      raise UserError(f'Kan {rec.name} niet verwijderen: heeft nog open orders.')
  return super().unlink()

# Logging standaard in elke module file
import logging
_logger = logging.getLogger(__name__)
# __name__ = 'odoo.addons.dispatch_iq_horeca.models.horeca_equipment'

class HorecaEquipment(models.Model):
  _name = 'horeca.equipment'

  def action_service_complete(self):
    for rec in self:
      _logger.info(
        'Service voltooid op apparaat %s (ID: %d) door gebruiker %s',
        rec.name, rec.id, self.env.user.name
      )
      # String formatting met % is efficiënter dan f-strings voor logging
      # (vermijdt string-opbouw als log level uitgeschakeld is)
      if not rec.last_service:
        _logger.warning(
          'Apparaat %s heeft geen last_service datum — mogelijke data-inconsistentie',
          rec.name
        )

# migrations/17.0.1.1.0/post-migrate.py
# Uitvoerd na -u dispatch_iq_horeca als nieuwe versie hoger is dan geïnstalleerde

def migrate(cr, version):
  if not version:
    return  # eerste installatie, geen migratie nodig

  # Vul nieuw veld 'refrigerant_type' in voor bestaande equipment
  cr.execute("""
    UPDATE horeca_equipment
    SET refrigerant_type = 'R32'
    WHERE refrigerant IS NOT NULL
      AND refrigerant ILIKE '%R32%'
      AND refrigerant_type IS NULL
  """)

  # Log hoeveel records bijgewerkt werden
  cr.execute("SELECT COUNT(*) FROM horeca_equipment WHERE refrigerant_type = 'R32'")
  count = cr.fetchone()[0]
  print(f'Migratie 17.0.1.1.0: {count} equipment records bijgewerkt met R32 type')

# store=False (default): altijd berekend, nooit in DB
response_time_hours = fields.Float(
  compute='_compute_response_time'
  # niet doorzoekbaar, niet in list view tenzij met context trick
)

# store=True: in DB, doorzoekbaar, sorteerbaar
parts_total = fields.Float(
  compute='_compute_parts_total',
  store=True
  # wordt herschreven bij elke wijziging van product_ids
)

from odoo.exceptions import ValidationError

class FsmOrderExtension(models.Model):
  _inherit = 'fsm.order'

  @api.constrains('scheduled_date_start', 'scheduled_date_end', 'equipment_id')
  def _check_no_equipment_overlap(self):
    for order in self:
      if not order.equipment_id:
        continue
      overlap = self.env['fsm.order'].search([
        ('id', '!=', order.id),
        ('equipment_id', '=', order.equipment_id.id),
        ('scheduled_date_start', '<', order.scheduled_date_end),
        ('scheduled_date_end', '>', order.scheduled_date_start),
      ], limit=1)
      if overlap:
        raise ValidationError(
          'Toestel %s heeft al een order in dit tijdvenster: %s'
          % (order.equipment_id.name, overlap.name)
        )

class HorecaEquipment(models.Model):
  _name = 'horeca.equipment'

  _sql_constraints = [
    (
      'unique_serial_per_company',
      'UNIQUE(serial_no, company_id)',
      'Serienummer moet uniek zijn per bedrijf.'
    ),
    (
      'positive_warranty_months',
      'CHECK(warranty_months >= 0)',
      'Garantiemaanden kunnen niet negatief zijn.'
    ),
  ]

@api.onchange('equipment_id')
def _onchange_equipment_id(self):
  if self.equipment_id:
    self.refrigerant_type = self.equipment_id.refrigerant_type
    self.equipment_category = self.equipment_id.category_id
    # waarschuwing als garantie verlopen
    if self.equipment_id.warranty_end < fields.Date.today():
      return {'warning': {
        'title': 'Garantie verlopen',
        'message': 'Dit toestel is buiten garantie. Informeer de klant voor aanvang.'
      }}
  else:
    self.refrigerant_type = False
    self.equipment_category = False

# Veilige manier: altijd guarden op False-waarden
@api.depends('equipment_id', 'equipment_id.last_service_date')
def _compute_days_since_service(self):
  today = fields.Date.today()
  for order in self:
    if order.equipment_id and order.equipment_id.last_service_date:
      delta = today - order.equipment_id.last_service_date
      order.days_since_service = delta.days
    else:
      order.days_since_service = 0  # nooit False laten staan bij Float-veld

from odoo.exceptions import ValidationError
from odoo.tests.common import TransactionCase

class TestOrderConstraints(TransactionCase):

  def test_negative_duration_blocked(self):
    with self.assertRaises(ValidationError):
      self.env['fsm.order'].create({
        'name': 'FSM/NEG/1',
        'duration': -1.5,
      })

  def test_zero_duration_allowed(self):
    # 0 is toegestaan: order nog niet gestart
    order = self.env['fsm.order'].create({
      'name': 'FSM/ZERO/1',
      'duration': 0,
    })
    self.assertEqual(order.duration, 0)

# SLECHT: cascade van 3 niveaus
parts_total = fields.Float(compute='_compute_parts_total', store=True)
is_high_value = fields.Boolean(compute='_compute_is_high_value', store=True)
priority_score = fields.Integer(compute='_compute_priority', store=True)

@api.depends('product_ids.price_unit', 'product_ids.qty_done')
def _compute_parts_total(self): ...  # OK: niveau 1

@api.depends('parts_total')  # niveau 2 — nog OK
def _compute_is_high_value(self): ...

@api.depends('is_high_value', 'urgency')  # niveau 3 — begin te vermijden
def _compute_priority(self): ...

# BETER: priority_score direct afhankelijk van parts_total
@api.depends('parts_total', 'urgency')
def _compute_priority(self): ...

<record id="view_horeca_equipment_tree" model="ir.ui.view">
  <field name="model">horeca.equipment</field>
  <field name="arch" type="xml">
    <tree string="Horeca Toestellen" default_order="name asc">
      <field name="name"/>
      <field name="serial_no"/>
      <field name="partner_id"/>
      <field name="refrigerant_type"/>
      <field name="warranty_end"/>
      <field name="power_kw" optional="show" sum="Totaal kW"/>
    </tree>
  </field>
</record>

<record id="view_fsm_order_kanban_horeca" model="ir.ui.view">
  <field name="model">fsm.order</field>
  <field name="arch" type="xml">
    <kanban default_group_by="stage_id">
      <field name="name"/>
      <field name="person_id"/>
      <field name="partner_id"/>
      <field name="is_high_value"/>
      <templates>
        <t t-name="kanban-box">
          <div t-att-class="'kanban-box' + (record.is_high_value.raw_value ? ' border-warning' : '')">
            <strong><t t-esc="record.name.value"/></strong>
            <div><t t-esc="record.partner_id.value"/></div>
            <div><t t-esc="record.person_id.value"/></div>
          </div>
        </t>
      </templates>
    </kanban>
  </field>
</record>

<record id="view_fsm_order_form_horeca" model="ir.ui.view">
  <field name="name">fsm.order.form.horeca</field>
  <field name="model">fsm.order</field>
  <field name="inherit_id" ref="fieldservice.view_fsm_order_form"/>
  <field name="arch" type="xml">
    <!-- na het bestaande 'person_id' veld -->
    <xpath expr="//field[@name='person_id']" position="after">
      <field name="refrigerant_type"/>
      <field name="equipment_category"/>
    </xpath>
    <!-- nieuw tabblad in de notebook -->
    <xpath expr="//notebook" position="inside">
      <page string="Horeca Details">
        <field name="parts_total"/>
        <field name="is_high_value"/>
      </page>
    </xpath>
  </field>
</record>

# models/fsm_order_extension.py
class FsmOrderHorecaExtension(models.Model):
  _inherit = 'fsm.order'
  _description = 'FSM Order Horeca Uitbreiding'

  refrigerant_type = fields.Selection([
    ('R32', 'R32'), ('R410A', 'R410A'),
    ('R290', 'R290'), ('R744', 'R744 (CO₂)'),
  ], string='Koelmiddel')

  equipment_category = fields.Selection([
    ('combi_steamer', 'Combi-Steamer'),
    ('blast_chiller', 'Blast Chiller'),
    ('cold_room', 'Koelcel'),
    ('display_fridge', 'Display Koelkast'),
  ], string='Toestelcategorie')

  lez_zone = fields.Boolean(
    string='LEZ Zone',
    related='location_id.is_lez_zone',
    store=True, readonly=True
  )

<!-- Actie om het model te openen -->
<record id="action_horeca_equipment" model="ir.actions.act_window">
  <field name="name">Horeca Toestellen</field>
  <field name="res_model">horeca.equipment</field>
  <field name="view_mode">tree,form,kanban</field>
</record>

<!-- Submenu onder Field Service -->
<menuitem
  id="menu_horeca_equipment"
  name="Horeca Toestellen"
  parent="fieldservice.menu_fieldservice_master"
  action="action_horeca_equipment"
  sequence="20"/>

<!-- Smart button in form view -->
<div class="oe_button_box" name="button_box">
  <button name="action_view_fsm_orders"
          type="object"
          class="oe_stat_button"
          icon="fa-wrench">
    <field name="fsm_order_count" widget="statinfo" string="Orders"/>
  </button>
</div>

# In het model: computed count + action
fsm_order_count = fields.Integer(compute='_compute_fsm_order_count')

def action_view_fsm_orders(self):
  return {
    'type': 'ir.actions.act_window',
    'res_model': 'fsm.order',
    'domain': [('equipment_id', '=', self.id)],
    'context': {'default_equipment_id': self.id},
    'view_mode': 'tree,form',
  }

<!-- Odoo 16: attrs met domain -->
<field name="equipment_id"
       attrs="{'readonly': [('stage_id.sequence', '>=', 3)]}"/>

<field name="refrigerant_type"
       attrs="{'readonly': [('stage_id.is_closed', '=', True)],
               'required': [('stage_id.sequence', '>=', 2)]}"/>

<!-- Veld tonen enkel voor managers -->
<field name="parts_cost_price"
       groups="dispatch_iq_horeca.group_manager"/>

<!-- FRAGIEL: positioneel -->
<xpath expr="//div[2]/group[1]" position="after"> <!-- BREEKT bij upstream layout-wijziging -->

<!-- ROBUUST: op veldnaam -->
<xpath expr="//field[@name='person_id']" position="after">

<!-- ROBUUST: op string-attribuut -->
<xpath expr="//page[@string='Extra Information']" position="inside">

<!-- Prioriteit: hogere waarde = later geladen -->
<field name="priority">32</field>  <!-- default is 16, OCA views zijn vaak 10-20 -->

<!-- reports/report_werkbon.xml -->
<record id="action_report_fsm_werkbon" model="ir.actions.report">
  <field name="name">Werkbon DispatchIQ</field>
  <field name="model">fsm.order</field>
  <field name="report_type">qweb-pdf</field>
  <field name="report_name">dispatch_iq_horeca.report_fsm_werkbon</field>
  <field name="report_file">dispatch_iq_horeca.report_fsm_werkbon</field>
  <field name="binding_model_id" ref="fieldservice.model_fsm_order"/>
  <field name="binding_type">report</field>
</record>

<!-- QWeb template -->
<template id="report_fsm_werkbon">
  <t t-call="web.html_container">
    <t t-foreach="docs" t-as="o">
      <t t-call="web.external_layout">
        <div class="page">
          <!-- werkbon inhoud hier -->
        </div>
      </t>
    </t>
  </t>
</template>

<div class="page">
  <h2>Werkbon — <t t-esc="o.name"/></h2>

  <div class="row">
    <div class="col-6">
      <strong>Klant:</strong> <t t-esc="o.partner_id.name"/><br/>
      <t t-esc="o.location_id.street"/>, <t t-esc="o.location_id.city"/>
    </div>
    <div class="col-6">
      <strong>Toestel:</strong> <t t-esc="o.equipment_id.name"/><br/>
      <strong>Serienr:</strong> <t t-esc="o.equipment_id.serial_no"/><br/>
      <strong>Koelmiddel:</strong> <t t-esc="o.refrigerant_type"/>
    </div>
  </div>

  <table class="table table-sm mt-4">
    <thead><tr>
      <th>Onderdeel</th><th class="text-right">Qty</th>
      <th class="text-right">Prijs</th><th class="text-right">Totaal</th>
    </tr></thead>
    <tbody>
      <t t-foreach="o.product_ids" t-as="line">
        <tr>
          <td><t t-esc="line.product_id.display_name"/></td>
          <td class="text-right"><t t-esc="line.qty_done"/></td>
          <td class="text-right"><t t-field="line.price_unit"/></td>
          <td class="text-right"><t t-esc="'%.2f' % (line.qty_done * line.price_unit)"/></td>
        </tr>
      </t>
    </tbody>
  </table>
</div>

<!-- CSS pagina-einde: start altijd op nieuwe pagina -->
<div class="page" style="page-break-after: always;">
  <!-- content pagina 1 -->
</div>

<!-- Header template -->
<template id="report_fsm_werkbon_header">
  <div class="header">
    <span t-esc="company.name"/> — BTW: <span t-esc="company.vat"/>
  </div>
</template>

<!-- Paginanummer in footer -->
<template id="report_fsm_werkbon_footer">
  <div class="footer">
    Pagina <span class="page"/> van <span class="topage"/>
  </div>
</template>

# model: Binary veld voor handtekening
class FsmOrderExtension(models.Model):
  _inherit = 'fsm.order'

  signature = fields.Binary(string='Handtekening klant', attachment=True)
  signature_date = fields.Datetime(string='Ondertekend op', readonly=True)

  def write(self, vals):
    if 'signature' in vals and vals['signature']:
      vals['signature_date'] = fields.Datetime.now()
    return super().write(vals)

<!-- XML view widget -->
<field name="signature" widget="signature"/>

<!-- QWeb: render als base64 img -->
<t t-if="o.signature">
  <img t-att-src="'data:image/png;base64,' + o.signature.decode()"
       style="height:80px; border-bottom: 1px solid #999;"/>
  <p>Ondertekend op: <t t-esc="o.signature_date"/></p>
</t>

def action_close_and_archive_pdf(self):
  """Sluit order af en slaat PDF op als bijlage."""
  for order in self:
    # Genereer PDF bytes via Odoo rapport engine
    pdf_content, _ = self.env['ir.actions.report']._render_qweb_pdf(
      'dispatch_iq_horeca.action_report_fsm_werkbon',
      [order.id]
    )
    # Sla op als bijlage
    self.env['ir.attachment'].create({
      'name': 'Werkbon_%s.pdf' % order.name.replace('/', '_'),
      'type': 'binary',
      'datas': base64.b64encode(pdf_content),
      'res_model': 'fsm.order',
      'res_id': order.id,
      'mimetype': 'application/pdf',
    })

# In het model
werkbon_template_version = fields.Char(
  string='Werkbon template versie',
  default='1.0', readonly=True
)

# Bij PDF-generatie altijd versie stampen
CURRENT_WERKBON_VERSION = '2.1'

def action_close_and_archive_pdf(self):
  for order in self:
    # ... PDF genereren ...
    order.write({
      'werkbon_template_version': CURRENT_WERKBON_VERSION
    })

# In de template: versie zichtbaar in footer
<small>Werkbon v<t t-esc="o.werkbon_template_version"/> — <t t-esc="o.name"/></small>

# Preload data in Python, niet in QWeb template
def _get_werkbon_data(self):
  """Bereid alle data voor in één query."""
  self.ensure_one()
  lines = self.product_ids.read([
    'product_id', 'qty_done', 'price_unit'
  ])
  partner = self.partner_id.read(['name', 'street', 'city', 'vat'])[0]
  return {
    'order': self,
    'lines': lines,
    'partner': partner,
    'total': sum(l['qty_done'] * l['price_unit'] for l in lines),
  }

/* CSS: verbreek tabelrijen niet halverwege een pagina */
tr { page-break-inside: avoid; }

class DispatchPersonSkill(models.Model):
  _name = 'dispatch.person.skill'
  _description = 'Technieker Competentie'

  person_id = fields.Many2one('fsm.person', required=True, ondelete='cascade')
  skill_id = fields.Many2one('dispatch.skill', required=True)
  level = fields.Selection([
    ('beginner', 'Beginner'),
    ('advanced', 'Gevorderd'),
    ('expert', 'Expert'),
  ], default='beginner')
  certificate_date = fields.Date(string='Certificaatdatum')
  expiry_date = fields.Date(
    string='Vervaldatum',
    compute='_compute_expiry_date', store=True
  )
  is_valid = fields.Boolean(
    string='Geldig', compute='_compute_is_valid'
  )

  @api.depends('certificate_date', 'skill_id.validity_months')
  def _compute_expiry_date(self):
    from dateutil.relativedelta import relativedelta
    for rec in self:
      if rec.certificate_date and rec.skill_id.validity_months:
        rec.expiry_date = rec.certificate_date + relativedelta(
          months=rec.skill_id.validity_months
        )
      else:
        rec.expiry_date = False

# wizards/dispatch_assign_wizard.py
class DispatchAssignWizard(models.TransientModel):
  _name = 'dispatch.assign.wizard'
  _description = 'Wizard: Technieker Toewijzen'

  order_id = fields.Many2one('fsm.order', required=True)
  technician_id = fields.Many2one('fsm.person', required=True)
  missing_skills = fields.Text(
    string='Ontbrekende skills',
    compute='_compute_missing_skills'
  )
  override_reason = fields.Text(string='Reden voor override')

  @api.depends('technician_id', 'order_id')
  def _compute_missing_skills(self):
    for wizard in self:
      if wizard.technician_id and wizard.order_id:
        missing = wizard.order_id.check_technician_skills(
          wizard.technician_id.id
        )
        wizard.missing_skills = ', '.join(missing) if missing else ''
      else:
        wizard.missing_skills = ''

class DispatchBulkRescheduleWizard(models.TransientModel):
  _name = 'dispatch.bulk.reschedule.wizard'

  order_ids = fields.Many2many(
    'fsm.order',
    default=lambda self: self.env.context.get('active_ids', [])
  )
  new_person_id = fields.Many2one('fsm.person', required=True)
  reschedule_reason = fields.Text(required=True)
  order_count = fields.Integer(
    compute='_compute_order_count', string='Aantal orders'
  )

  def action_confirm_reschedule(self):
    for order in self.order_ids:
      order.person_id = self.new_person_id.id
      order.message_post(body='Herplanning: %s' % self.reschedule_reason)
    return {'type': 'ir.actions.act_window_close'}

def action_confirm(self):
  """Valideer en wijs toe. Raise ValidationError bij problemen."""
  # 1. Skills check
  missing = self.order_id.check_technician_skills(self.technician_id.id)
  if missing and not self.override_reason:
    raise ValidationError(
      'Technieker %s mist skills: %s.\n'
      'Geef een override-reden als je toch wil doorgaan.'
      % (self.technician_id.name, ', '.join(missing))
    )

  # 2. Beschikbaarheid check
  if not self.technician_id.active:
    raise ValidationError('Technieker %s is inactief.' % self.technician_id.name)

  # 3. Alles OK: wijs toe
  self.order_id.person_id = self.technician_id.id
  if missing:
    self.order_id.message_post(
      body='⚠ Override: %s. Ontbrekende skills: %s'
           % (self.override_reason, ', '.join(missing))
    )
  return {'type': 'ir.actions.act_window_close'}

# Python: methode die de wizard opent
def action_open_assign_wizard(self):
  return {
    'type': 'ir.actions.act_window',
    'name': 'Technieker Toewijzen',
    'res_model': 'dispatch.assign.wizard',
    'view_mode': 'form',
    'target': 'new',  # popup
    'context': {'default_order_id': self.id},
  }

<!-- XML: knop op form view, enkel zichtbaar in juiste stage -->
<button name="action_open_assign_wizard"
        string="Technieker Toewijzen"
        type="object"
        class="btn-primary"
        icon="fa-user-plus"
        attrs="{'invisible': [('stage_id.sequence', '>=', 3)]}"/>

def _get_suggested_technicians(self):
  """Geef geschikte alternatieve techniekers terug."""
  order = self.order_id
  required_skills = order.required_skill_ids.mapped('skill_id')

  # Alle actieve techniekers
  candidates = self.env['fsm.person'].search([
    ('active', '=', True),
    ('id', '!=', order.person_id.id),
  ])

  result = []
  for tech in candidates:
    tech_skills = tech.skill_ids.filtered('is_valid').mapped('skill_id')
    missing = required_skills - tech_skills
    if not missing:  # geen ontbrekende skills
      # check geen overlap
      overlap = self.env['fsm.order'].search_count([
        ('person_id', '=', tech.id),
        ('scheduled_date_start', '<', order.scheduled_date_end),
        ('scheduled_date_end', '>', order.scheduled_date_start),
      ])
      if not overlap:
        result.append(tech.id)
  return result

class DispatchAssignmentLog(models.Model):
  _name = 'dispatch.assignment.log'
  _description = 'Toewijzingsaudit'
  _order = 'create_date desc'

  order_id = fields.Many2one('fsm.order', ondelete='cascade')
  assigned_by = fields.Many2one('res.users', default=lambda s: s.env.uid)
  technician_id = fields.Many2one('fsm.person')
  had_skill_override = fields.Boolean()
  override_reason = fields.Text()
  missing_skills_at_time = fields.Text()

# In wizard action_confirm:
self.env['dispatch.assignment.log'].create({
  'order_id': self.order_id.id,
  'technician_id': self.technician_id.id,
  'had_skill_override': bool(missing),
  'override_reason': self.override_reason,
  'missing_skills_at_time': ', '.join(missing),
})

<!-- security/record_rules.xml -->
<odoo>
  <record id="rule_fsm_order_technician" model="ir.rule">
    <field name="name">FSM Order: technieker ziet enkel eigen orders</field>
    <field name="model_id" ref="fieldservice.model_fsm_order"/>
    <field name="groups" eval="[(4, ref('dispatch_iq_horeca.group_technician'))]"/>
    <field name="domain_force">[('person_id.partner_id.user_ids', 'in', [user.id])]</field>
    <field name="perm_read" eval="True"/>
    <field name="perm_write" eval="True"/>
    <field name="perm_create" eval="False"/>
    <field name="perm_unlink" eval="False"/>
  </record>
</odoo>

from odoo.exceptions import AccessError
from odoo.tests.common import TransactionCase

class TestSecurityRoles(TransactionCase):

  def setUp(self):
    super().setUp()
    group_tech = self.env.ref('dispatch_iq_horeca.group_technician')
    self.jonas = self.env['res.users'].create({
      'name': 'Jonas Test', 'login': 'jonas_test',
      'groups_id': [(4, group_tech.id)]
    })
    self.order_other = self.env['fsm.order'].create({
      'name': 'FSM/OTHER/1'
      # geen person_id = Jonas
    })

  def test_technician_cannot_see_other_orders(self):
    orders = self.env['fsm.order'].with_user(self.jonas).search([])
    order_ids = orders.ids
    self.assertNotIn(self.order_other.id, order_ids)

  def test_technician_cannot_delete(self):
    with self.assertRaises(AccessError):
      self.order_other.with_user(self.jonas).unlink()

from odoo.tests.common import TransactionCase
from odoo.exceptions import ValidationError

class TestFsmOrderBusiness(TransactionCase):

  def setUp(self):
    super().setUp()
    self.equipment = self.env['horeca.equipment'].create({
      'name': 'Combi-Steamer RX',
      'serial_no': 'CS-001-TEST',
      'refrigerant_type': 'R32',
    })

  def test_parts_total_computed_correctly(self):
    order = self.env['fsm.order'].create({'name': 'FSM/CT/1'})
    # voeg productregels toe en check computed total
    self.assertEqual(order.parts_total, 0.0)

  def test_duplicate_serial_blocked(self):
    with self.assertRaises(Exception):  # IntegrityError of ValidationError
      self.env['horeca.equipment'].create({
        'name': 'Ander toestel',
        'serial_no': 'CS-001-TEST',  # dubbel!
      })

from odoo.tests.common import HttpCase

class TestWerkbonReport(HttpCase):

  def test_werkbon_pdf_renders(self):
    # Maak een testorder aan
    order = self.env['fsm.order'].create({'name': 'FSM/PDF/1'})
    # Vraag de PDF op via HTTP
    response = self.url_open(
      '/report/pdf/dispatch_iq_horeca.action_report_fsm_werkbon/%d' % order.id
    )
    self.assertEqual(response.status_code, 200)
    self.assertEqual(response.headers['Content-Type'], 'application/pdf')
    self.assertGreater(len(response.content), 1000)  # niet leeg

  def test_tour_assign_technician(self):
    self.start_tour(
      "/web#action=fieldservice.action_fsm_order",
      "dispatch_assign_tour",
      login="admin"
    )

# .github/workflows/test.yml
name: Test dispatch_iq_horeca

on: [push, pull_request]

jobs:
  test:
    runs-on: ubuntu-latest
    services:
      postgres:
        image: postgres:15
        env:
          POSTGRES_USER: odoo
          POSTGRES_PASSWORD: odoo
          POSTGRES_DB: odoo_test
    steps:
      - uses: actions/checkout@v3
      - name: Run Odoo tests
        run: |
          docker run --network host \
            -e DB_HOST=localhost -e DB_USER=odoo -e DB_PASSWORD=odoo \
            -v $(pwd):/mnt/extra-addons \
            odoo:16 \
            odoo --test-enable \
                 --test-tags=dispatch_iq_horeca \
                 -d odoo_test \
                 -i dispatch_iq_horeca \
                 --stop-after-init

class TestSecuritySmoke(TransactionCase):

  def test_technician_cannot_escalate_to_manager(self):
    group_tech = self.env.ref('dispatch_iq_horeca.group_technician')
    group_mgr = self.env.ref('dispatch_iq_horeca.group_manager')
    tech_user = self.env['res.users'].create({
      'name': 'Jonas', 'login': 'j_smoke',
      'groups_id': [(4, group_tech.id)]
    })
    with self.assertRaises(AccessError):
      tech_user.with_user(tech_user).write({
        'groups_id': [(4, group_mgr.id)]
      })

  def test_dispatch_log_not_accessible_by_technician(self):
    group_tech = self.env.ref('dispatch_iq_horeca.group_technician')
    tech_user = self.env['res.users'].create({
      'name': 'Jonas2', 'login': 'j_smoke2',
      'groups_id': [(4, group_tech.id)]
    })
    with self.assertRaises(AccessError):
      self.env['dispatch.assignment.log'].with_user(tech_user).search([])

# __manifest__.py versie bump
{
  'name': 'DispatchIQ Horeca',
  'version': '16.0.1.2.0',  # Odoo versie + MAJOR.MINOR.PATCH
  'depends': ['fieldservice', 'fieldservice_stock'],
}

# migrations/16.0.1.2.0/pre-migrate.py
def migrate(cr, version):
  """Rename column refrigerant naar refrigerant_type."""
  cr.execute("""
    ALTER TABLE fsm_order
    RENAME COLUMN refrigerant TO refrigerant_type
  """)

# Rollback procedure (README.md sectie)
# 1. Stop Odoo
# 2. git checkout v1.1.0 (vorige versie)
# 3. pg_restore backup_pre_deploy.dump → herstel DB
# 4. ./odoo-bin -u dispatch_iq_horeca --stop-after-init
# 5. Start Odoo