更新登录页及优化相关功能

shierfeng-fastapi-backend/module_business/service/usage_service.py

@@ -16,14 +16,18 @@ from module_business.dao.access_dao import AccessDao
 from module_business.dao.inventory_dao import InventoryDao
 from module_business.dao.master_dao import MasterDao
 from module_business.dao.operation_dao import OperationDao
+from module_business.dao.usage_fifo_dao import UsageFifoDao
 from module_business.domain.enums import PalletEventType, PalletFlowState
+from module_business.domain.fifo_policy import requires_fifo_skip_reason
 from module_business.domain.pallet_state_machine import PalletStateMachine
 from module_business.domain.test_batch_scope import TestBatchScope, assert_record_in_scope
-from module_business.entity.do.operation_do import BizPalletEvent, BizUsageRecord
-from module_business.entity.vo.master_vo import LinePageQueryModel
+from module_business.entity.do.operation_do import BizFillingRecord, BizPalletEvent, BizPalletInventory, BizUsageRecord
+from module_business.entity.vo.master_vo import LinePageQueryModel, TunnelPageQueryModel
 from module_business.entity.vo.operation_vo import (
     BusinessOptionModel,
     PalletScanResponseModel,
+    TunnelEntryCreateModel,
+    TunnelEntrySuccessResponseModel,
     UsageCreateModel,
     UsageModel,
     UsagePageQueryModel,
@@ -31,6 +35,7 @@ from module_business.entity.vo.operation_vo import (
 )
 from module_business.service.access_service import AccessService
 from module_business.service.test_batch_access_service import TestBatchAccessService
+from module_business.service.usage_transaction import retry_mysql_lock_conflicts
 
 
 class UsageService:
@@ -110,17 +115,52 @@ class UsageService:
 
     @staticmethod
     def _build_request_hash(page_object: UsageCreateModel) -> str:
+        fields = {
+            'qr_token': page_object.qr_token.strip(),
+            'tunnel_id': page_object.tunnel_id,
+            'line_id': page_object.line_id,
+            'used_packages': page_object.used_packages,
+        }
+        # 无原因时保留原摘要，迁移前已成功的请求仍可按原键安全重放。
+        if page_object.fifo_skip_reason:
+            fields['fifo_skip_reason'] = page_object.fifo_skip_reason
         payload = json.dumps(
-            {
-                'qr_token': page_object.qr_token.strip(),
-                'line_id': page_object.line_id,
-                'used_packages': page_object.used_packages,
-            },
+            fields,
             sort_keys=True,
             separators=(',', ':'),
         ).encode()
         return hashlib.sha256(payload).hexdigest()
 
+    @staticmethod
+    async def _check_fifo_skip(
+        query_db: AsyncSession,
+        inventory: BizPalletInventory,
+        filling: BizFillingRecord,
+        tunnel_id: int,
+        trace_no: str | None,
+        reason: str | None,
+        test_scope: TestBatchScope,
+    ) -> dict[str, Any] | None:
+        if inventory.site_arrived_at is None:
+            return None
+        candidate, _ = await UsageFifoDao.recommendation(
+            query_db, site_id=inventory.site_id, strain_id=filling.strain_id,
+            tunnel_id=tunnel_id, trace_no=trace_no, scope=test_scope, for_update=True,
+        )
+        if not requires_fifo_skip_reason(inventory.pallet_id, inventory.site_arrived_at, candidate):
+            return None
+        if not reason:
+            raise ServiceException(
+                data='FIFO_SKIP_REASON_REQUIRED',
+                message=f'存在先到托盘 {candidate["pallet_code"]}，请填写跳过原因后重新提交',
+            )
+        return {
+            'palletId': candidate['pallet_id'], 'palletCode': candidate['pallet_code'],
+            'batchNo': candidate['batch_no'], 'remainingPackages': candidate['remaining_packages'],
+            'siteArrivedAt': candidate['site_arrived_at'].isoformat(),
+            'selectedSiteArrivedAt': inventory.site_arrived_at.isoformat(),
+        }
+
     @staticmethod
     def _is_exact_idempotent_result(
         usage: BizUsageRecord,
@@ -143,6 +183,32 @@ class UsageService:
             ),
         )
 
+    @staticmethod
+    def _tunnel_entry_success(pallet_id: int, tunnel_id: int, trace_no: str) -> CrudResponseModel:
+        return CrudResponseModel(
+            is_success=True,
+            message='扫码入隧成功',
+            result=TunnelEntrySuccessResponseModel(
+                pallet_id=pallet_id,
+                tunnel_id=tunnel_id,
+                trace_no=trace_no,
+            ),
+        )
+
+    @staticmethod
+    def _is_exact_tunnel_entry_result(
+        event: BizPalletEvent,
+        page_object: TunnelEntryCreateModel,
+        request_hash: str,
+    ) -> bool:
+        return (
+            event.event_type == PalletEventType.TUNNEL_ENTERED.value
+            and event.after_tunnel_id == page_object.tunnel_id
+            and event.idempotency_key == page_object.idempotency_key
+            and event.request_hash == request_hash
+            and bool(event.trace_no)
+        )
+
     @classmethod
     async def _lock_and_reauthorize_usage_site(
         cls,
@@ -294,7 +360,274 @@ class UsageService:
         return sorted(options, key=lambda option: option.id)
 
     @classmethod
-    async def scan_usage_pallet_services(
+    async def get_tunnel_options_services(
+        cls,
+        query_db: AsyncSession,
+        site_id: int,
+        current_user: CurrentUserModel,
+        test_scope: TestBatchScope,
+    ) -> list[BusinessOptionModel]:
+        cls._current_identity(current_user)
+        await AccessService.assert_site_access(query_db, current_user, site_id)
+        site = await MasterDao.get_site(query_db, site_id, test_scope)
+        if site is None:
+            raise ServiceException(message='客户现场不存在')
+        assert_record_in_scope(site, test_scope, '现场')
+        if site.status != '0':
+            raise ServiceException(message='客户现场已停用')
+        tunnels = await MasterDao.list_tunnel(
+            query_db,
+            TunnelPageQueryModel(siteId=site_id, status='0'),
+            test_scope,
+            False,
+        )
+        options = [
+            BusinessOptionModel(
+                id=cls._record_value(tunnel, 'tunnel_id'),
+                code=cls._record_value(tunnel, 'tunnel_code'),
+                name=cls._record_value(tunnel, 'tunnel_name'),
+            )
+            for tunnel in tunnels
+            if cls._record_value(tunnel, 'site_id') == site_id and cls._record_value(tunnel, 'status') == '0'
+        ]
+        return sorted(options, key=lambda option: option.id)
+
+    @staticmethod
+    def _build_tunnel_entry_request_hash(page_object: TunnelEntryCreateModel) -> str:
+        fields = {'qr_token': page_object.qr_token.strip(), 'tunnel_id': page_object.tunnel_id}
+        if page_object.fifo_skip_reason:
+            fields['fifo_skip_reason'] = page_object.fifo_skip_reason
+        payload = json.dumps(
+            fields,
+            sort_keys=True,
+            separators=(',', ':'),
+        ).encode()
+        return hashlib.sha256(payload).hexdigest()
+
+    @classmethod
+    async def _recover_tunnel_entry_integrity_error(
+        cls,
+        query_db: AsyncSession,
+        page_object: TunnelEntryCreateModel,
+        request_hash: str,
+        current_user: CurrentUserModel,
+        test_scope: TestBatchScope,
+    ) -> CrudResponseModel:
+        try:
+            await TestBatchAccessService.lock_active_batch(query_db, test_scope)
+            pallet = await InventoryDao.get_pallet_by_qr_token(
+                query_db,
+                page_object.qr_token.strip(),
+                test_scope,
+            )
+            if pallet is None:
+                cls._raise_pallet_not_accessible(current_user)
+            event = await InventoryDao.get_event_by_idempotency_key(
+                query_db,
+                pallet.pallet_id,
+                page_object.idempotency_key,
+                test_scope,
+            )
+            if event is None or not cls._is_exact_tunnel_entry_result(event, page_object, request_hash):
+                raise ServiceException(message='扫码入隧失败，幂等键已被其他请求使用')
+            return cls._tunnel_entry_success(pallet.pallet_id, page_object.tunnel_id, event.trace_no)
+        finally:
+            await query_db.rollback()
+
+    @classmethod
+    @retry_mysql_lock_conflicts
+    async def enter_tunnel_services(  # noqa: PLR0912, PLR0915
+        cls,
+        query_db: AsyncSession,
+        page_object: TunnelEntryCreateModel,
+        current_user: CurrentUserModel,
+        test_scope: TestBatchScope,
+    ) -> CrudResponseModel:
+        try:
+            await TestBatchAccessService.lock_active_batch(query_db, test_scope)
+            request_hash = cls._build_tunnel_entry_request_hash(page_object)
+            user_id, user_name = cls._current_identity(current_user)
+            pallet = await InventoryDao.get_pallet_by_qr_token(
+                query_db,
+                page_object.qr_token.strip(),
+                test_scope,
+            )
+            if pallet is None:
+                cls._raise_pallet_not_accessible(current_user)
+            assert_record_in_scope(pallet, test_scope, '托盘')
+            tunnel = await MasterDao.get_tunnel(query_db, page_object.tunnel_id, test_scope)
+            if tunnel is None:
+                raise ServiceException(message='隧道不存在')
+            assert_record_in_scope(tunnel, test_scope, '隧道')
+            if tunnel.status != '0':
+                raise ServiceException(message='隧道已停用')
+            preflight_tunnel_site_id = tunnel.site_id
+            await cls._assert_pallet_site_access(query_db, current_user, tunnel.site_id)
+
+            existing = await InventoryDao.get_event_by_idempotency_key(
+                query_db,
+                pallet.pallet_id,
+                page_object.idempotency_key,
+                test_scope,
+            )
+            if existing is not None:
+                assert_record_in_scope(existing, test_scope, '托盘事件')
+                if not cls._is_exact_tunnel_entry_result(existing, page_object, request_hash):
+                    raise ServiceException(message='扫码入隧失败，幂等键已被其他请求使用')
+                result = cls._tunnel_entry_success(pallet.pallet_id, page_object.tunnel_id, existing.trace_no)
+                await query_db.rollback()
+                return result
+
+            # rollback 会令 ORM 属性过期；跨事务只传普通值，不触发隐式异步加载。
+            scanned_pallet_id = pallet.pallet_id
+            await query_db.rollback()
+            await TestBatchAccessService.lock_active_batch(query_db, test_scope)
+            inventory = await InventoryDao.get_inventory_for_update(query_db, scanned_pallet_id, test_scope)
+            if inventory is None:
+                cls._raise_pallet_not_accessible(current_user, '托盘库存不存在')
+            assert_record_in_scope(inventory, test_scope, '库存')
+            if inventory.site_id is None:
+                cls._raise_pallet_not_accessible(current_user, '托盘不在客户现场')
+            await cls._assert_pallet_site_access(query_db, current_user, inventory.site_id)
+            if inventory.site_id != preflight_tunnel_site_id:
+                raise ServiceException(message='隧道不属于托盘当前客户现场')
+
+            locked_pallets = await InventoryDao.get_pallets_by_ids(
+                query_db,
+                [inventory.pallet_id],
+                test_scope,
+            )
+            if len(locked_pallets) != 1 or locked_pallets[0].pallet_id != inventory.pallet_id:
+                cls._raise_pallet_not_accessible(current_user)
+            pallet = locked_pallets[0]
+            assert_record_in_scope(pallet, test_scope, '托盘')
+            tunnel = await MasterDao.get_tunnel(
+                query_db,
+                page_object.tunnel_id,
+                test_scope,
+                for_update=True,
+            )
+            if tunnel is None:
+                raise ServiceException(message='隧道不存在')
+            assert_record_in_scope(tunnel, test_scope, '隧道')
+            if tunnel.status != '0':
+                raise ServiceException(message='隧道已停用')
+            if tunnel.site_id != inventory.site_id:
+                raise ServiceException(message='隧道不属于托盘当前客户现场')
+            existing = await InventoryDao.get_event_by_idempotency_key(
+                query_db,
+                pallet.pallet_id,
+                page_object.idempotency_key,
+                test_scope,
+            )
+            if existing is not None:
+                assert_record_in_scope(existing, test_scope, '托盘事件')
+                if not cls._is_exact_tunnel_entry_result(existing, page_object, request_hash):
+                    raise ServiceException(message='扫码入隧失败，幂等键已被其他请求使用')
+                result = cls._tunnel_entry_success(pallet.pallet_id, page_object.tunnel_id, existing.trace_no)
+                await query_db.rollback()
+                return result
+
+            if pallet.asset_status != '0':
+                raise ServiceException(message='托盘资产已停用，不允许入隧')
+            if (
+                inventory.flow_state
+                not in {
+                    PalletFlowState.AT_SITE_UNUSED.value,
+                    PalletFlowState.AT_SITE_PARTIAL.value,
+                }
+                or inventory.warehouse_id is not None
+                or inventory.active_filling_id is None
+                or type(inventory.remaining_packages) is not int
+                or inventory.remaining_packages <= 0
+                or inventory.remaining_packages > pallet.capacity_packages
+            ):
+                raise ServiceException(message='托盘当前状态不允许入隧')
+            filling = await OperationDao.get_active_filling_for_update(
+                query_db,
+                inventory.active_filling_id,
+                test_scope,
+            )
+            if filling is None:
+                raise ServiceException(message='托盘活动装填周期不存在或已关闭')
+            assert_record_in_scope(filling, test_scope, '活动装填')
+            if (
+                filling.pallet_id != pallet.pallet_id
+                or filling.active_slot != 'ACTIVE'
+                or filling.closed_at is not None
+            ):
+                raise ServiceException(message='托盘活动装填周期无效')
+            if inventory.tunnel_id is not None:
+                if inventory.tunnel_id == tunnel.tunnel_id and inventory.trace_no == tunnel.current_trace_no:
+                    raise ServiceException(message='托盘已入当前隧道')
+                raise ServiceException(message='托盘已入其他隧道')
+            if inventory.trace_no is not None:
+                raise ServiceException(message='托盘隧道溯源状态不一致')
+            fifo_snapshot = await cls._check_fifo_skip(
+                query_db, inventory, filling, tunnel.tunnel_id, tunnel.current_trace_no,
+                page_object.fifo_skip_reason, test_scope,
+            )
+            if tunnel.current_trace_no is None:
+                tunnel.current_trace_no = f'TN-{secrets.token_hex(16)}'
+                tunnel.current_trace_started_at = datetime.now()
+            elif not tunnel.current_trace_no.strip():
+                raise ServiceException(message='隧道当前溯源号无效')
+
+            current_time = datetime.now()
+            before_state = inventory.flow_state
+            before_remaining_packages = inventory.remaining_packages
+            inventory.tunnel_id = tunnel.tunnel_id
+            inventory.trace_no = tunnel.current_trace_no
+            inventory.version += 1
+            inventory.updated_at = current_time
+            event = BizPalletEvent(
+                pallet_id=inventory.pallet_id,
+                event_type=PalletEventType.TUNNEL_ENTERED.value,
+                source_type='TUNNEL',
+                source_id=tunnel.tunnel_id,
+                fifo_skip_reason=page_object.fifo_skip_reason,
+                fifo_recommendation=fifo_snapshot,
+                before_state=before_state,
+                after_state=inventory.flow_state,
+                before_warehouse_id=inventory.warehouse_id,
+                before_site_id=inventory.site_id,
+                before_tunnel_id=None,
+                before_line_id=inventory.current_line_id,
+                after_warehouse_id=inventory.warehouse_id,
+                after_site_id=inventory.site_id,
+                after_tunnel_id=inventory.tunnel_id,
+                after_line_id=inventory.current_line_id,
+                before_remaining_packages=before_remaining_packages,
+                after_remaining_packages=inventory.remaining_packages,
+                trace_no=inventory.trace_no,
+                batch_no_snapshot=filling.batch_no,
+                operator_id=user_id,
+                occurred_at=current_time,
+                idempotency_key=page_object.idempotency_key,
+                request_hash=request_hash,
+                test_batch_id=test_scope.batch_id,
+            )
+            await InventoryDao.add_event(query_db, inventory, event, test_scope)
+            tunnel.update_by = user_name
+            tunnel.update_time = current_time
+            result = cls._tunnel_entry_success(pallet.pallet_id, tunnel.tunnel_id, tunnel.current_trace_no)
+            await query_db.commit()
+            return result
+        except IntegrityError:
+            await query_db.rollback()
+            return await cls._recover_tunnel_entry_integrity_error(
+                query_db,
+                page_object,
+                cls._build_tunnel_entry_request_hash(page_object),
+                current_user,
+                test_scope,
+            )
+        except Exception:
+            await query_db.rollback()
+            raise
+
+    @classmethod
+    async def scan_usage_pallet_services(  # noqa: PLR0912
         cls,
         query_db: AsyncSession,
         qr_token: str,
@@ -314,7 +647,7 @@ class UsageService:
             cls._raise_pallet_not_accessible(current_user, '托盘不在客户现场')
         await cls._assert_pallet_site_access(query_db, current_user, inventory.site_id)
 
-        if pallet.qr_token != normalized_qr or pallet.pallet_id != inventory.pallet_id:
+        if normalized_qr not in {pallet.qr_token, pallet.pallet_code} or pallet.pallet_id != inventory.pallet_id:
             raise ServiceException(message='托盘二维码与库存不一致')
         if pallet.asset_status != '0':
             raise ServiceException(message='托盘资产已停用，不允许使用')
@@ -328,7 +661,7 @@ class UsageService:
             or inventory.active_filling_id is None
             or type(inventory.remaining_packages) is not int
             or inventory.remaining_packages <= 0
-            or inventory.remaining_packages > pallet.capacity_packages
+                or inventory.remaining_packages > pallet.capacity_packages
         ):
             raise ServiceException(message='托盘当前状态不允许使用')
         filling = await OperationDao.get_filling_by_id(query_db, inventory.active_filling_id, test_scope)
@@ -342,25 +675,43 @@ class UsageService:
             or filling.closed_at is not None
         ):
             raise ServiceException(message='托盘活动装填周期无效')
+        allowed_actions = ['usage']
+        if inventory.tunnel_id is None:
+            allowed_actions = ['enter_tunnel']
+        else:
+            if inventory.trace_no is None:
+                raise ServiceException(message='托盘隧道溯源状态不一致')
+            tunnel = await MasterDao.get_tunnel(query_db, inventory.tunnel_id, test_scope)
+            if tunnel is None or tunnel.site_id != inventory.site_id:
+                raise ServiceException(message='托盘当前隧道不存在或现场不一致')
+            assert_record_in_scope(tunnel, test_scope, '隧道')
+            if tunnel.status != '0' or tunnel.current_trace_no != inventory.trace_no:
+                raise ServiceException(message='托盘当前隧道已停用或溯源状态不一致')
         return PalletScanResponseModel(
             pallet_id=pallet.pallet_id,
+            qr_token=pallet.qr_token,
             pallet_code=pallet.pallet_code,
             flow_state=PalletFlowState(inventory.flow_state),
             warehouse_id=None,
             site_id=inventory.site_id,
+            tunnel_id=inventory.tunnel_id,
+            trace_no=inventory.trace_no,
             current_line_id=inventory.current_line_id,
             active_filling_id=inventory.active_filling_id,
             strain_id=filling.strain_id,
             strain_code=filling.strain_code_snapshot,
             strain_name=filling.strain_name_snapshot,
             batch_no=filling.batch_no,
+            production_date=filling.production_date,
+            expiry_date=filling.expiry_date,
             package_spec=filling.package_spec,
             capacity_packages=pallet.capacity_packages,
             remaining_packages=inventory.remaining_packages,
-            allowed_actions=['usage'],
+            allowed_actions=allowed_actions,
         )
 
     @classmethod
+    @retry_mysql_lock_conflicts
     async def record_usage_services(  # noqa: PLR0912, PLR0915
         cls,
         query_db: AsyncSession,
@@ -374,11 +725,16 @@ class UsageService:
             request_hash = cls._build_request_hash(page_object)
             user_id, user_name = cls._current_identity(current_user)
             preflight_site_ids = await cls._site_scope(query_db, current_user)
-            # 产线归属是请求内稳定路由；锁事务仍以库存中的实际现场复核。
-            preflight_line = await MasterDao.get_line(query_db, page_object.line_id, test_scope)
-            if preflight_line is not None:
-                assert_record_in_scope(preflight_line, test_scope, '产线')
-            preflight_site_id = preflight_line.site_id if preflight_line is not None else None
+            preflight_tunnel = await MasterDao.get_tunnel(query_db, page_object.tunnel_id, test_scope)
+            if preflight_tunnel is None:
+                raise ServiceException(message='隧道不存在')
+            assert_record_in_scope(preflight_tunnel, test_scope, '隧道')
+            preflight_site_id = preflight_tunnel.site_id
+            if page_object.line_id is not None:
+                # 仅在预检阶段读取产线以确定批次范围；状态和实际现场归属在锁定库存后复核。
+                preflight_line = await MasterDao.get_line(query_db, page_object.line_id, test_scope)
+                if preflight_line is not None:
+                    assert_record_in_scope(preflight_line, test_scope, '产线')
             existing = None
             if preflight_site_id is not None and (
                 preflight_site_ids is None or preflight_site_id in preflight_site_ids
@@ -494,14 +850,34 @@ class UsageService:
             assert_record_in_scope(site, test_scope, '现场')
             if site.status != '0':
                 raise ServiceException(message='客户现场已停用')
-            line = await MasterDao.get_line(query_db, page_object.line_id, test_scope, for_update=True)
-            if line is None:
-                raise ServiceException(message='产线不存在')
-            assert_record_in_scope(line, test_scope, '产线')
-            if line.status != '0':
-                raise ServiceException(message='产线已停用')
-            if line.site_id != inventory.site_id:
-                raise ServiceException(message='产线不属于托盘当前客户现场')
+            tunnel = await MasterDao.get_tunnel(
+                query_db,
+                page_object.tunnel_id,
+                test_scope,
+                for_update=True,
+            )
+            if tunnel is None:
+                raise ServiceException(message='隧道不存在')
+            assert_record_in_scope(tunnel, test_scope, '隧道')
+            if tunnel.status != '0':
+                raise ServiceException(message='隧道已停用')
+            if tunnel.site_id != inventory.site_id:
+                raise ServiceException(message='隧道不属于托盘当前客户现场')
+            if inventory.tunnel_id != tunnel.tunnel_id or not inventory.trace_no:
+                raise ServiceException(message='托盘尚未扫码入当前隧道')
+            if tunnel.current_trace_no != inventory.trace_no:
+                raise ServiceException(message='托盘与隧道的物料溯源号不一致')
+
+            line = None
+            if page_object.line_id is not None:
+                line = await MasterDao.get_line(query_db, page_object.line_id, test_scope, for_update=True)
+                if line is None:
+                    raise ServiceException(message='产线不存在')
+                assert_record_in_scope(line, test_scope, '产线')
+                if line.status != '0':
+                    raise ServiceException(message='产线已停用')
+                if line.site_id != inventory.site_id:
+                    raise ServiceException(message='产线不属于托盘当前客户现场')
 
             if pallet.pallet_id != inventory.pallet_id or pallet.qr_token != page_object.qr_token.strip():
                 raise ServiceException(message='托盘二维码与库存不一致')
@@ -527,13 +903,22 @@ class UsageService:
                 or filling.closed_at is not None
             ):
                 raise ServiceException(message='托盘活动装填周期无效')
-            if inventory.current_line_id is not None and inventory.current_line_id != line.line_id:
+            if (
+                line is not None
+                and inventory.current_line_id is not None
+                and inventory.current_line_id != line.line_id
+            ):
                 raise ServiceException(message='托盘本次驻场周期已绑定其他产线')
             if type(page_object.used_packages) is not int or page_object.used_packages <= 0:
                 raise ServiceException(message='使用包数必须为正整数')
             if page_object.used_packages > inventory.remaining_packages:
                 raise ServiceException(message='使用包数不能超过当前余量')
 
+            fifo_snapshot = await cls._check_fifo_skip(
+                query_db, inventory, filling, tunnel.tunnel_id, inventory.trace_no,
+                page_object.fifo_skip_reason, test_scope,
+            )
+
             remaining_after = inventory.remaining_packages - page_object.used_packages
             target_state = PalletFlowState.AT_SITE_EMPTY if remaining_after == 0 else PalletFlowState.AT_SITE_PARTIAL
             PalletStateMachine.ensure_transition(
@@ -543,11 +928,16 @@ class UsageService:
 
             current_time = datetime.now()
             usage = BizUsageRecord(
+                fifo_skip_reason=page_object.fifo_skip_reason,
+                fifo_recommendation=fifo_snapshot,
                 usage_no=f'US-{secrets.token_hex(16)}',
                 pallet_id=pallet.pallet_id,
                 active_filling_id=filling.filling_id,
                 site_id=inventory.site_id,
-                line_id=line.line_id,
+                tunnel_id=tunnel.tunnel_id,
+                trace_no=inventory.trace_no,
+                batch_no_snapshot=filling.batch_no,
+                line_id=line.line_id if line is not None else inventory.current_line_id,
                 used_packages=page_object.used_packages,
                 remaining_packages_after=remaining_after,
                 idempotency_key=page_object.idempotency_key,
@@ -564,9 +954,12 @@ class UsageService:
             before_state = inventory.flow_state
             before_warehouse_id = inventory.warehouse_id
             before_site_id = inventory.site_id
+            before_tunnel_id = inventory.tunnel_id
+            before_trace_no = inventory.trace_no
             before_line_id = inventory.current_line_id
             before_remaining_packages = inventory.remaining_packages
-            inventory.current_line_id = line.line_id
+            if line is not None:
+                inventory.current_line_id = line.line_id
             inventory.remaining_packages = remaining_after
             inventory.flow_state = target_state.value
             if target_state is PalletFlowState.AT_SITE_EMPTY:
@@ -583,16 +976,22 @@ class UsageService:
                 event_type=PalletEventType.USAGE_RECORDED.value,
                 source_type='USAGE',
                 source_id=usage_id,
+                fifo_skip_reason=page_object.fifo_skip_reason,
+                fifo_recommendation=fifo_snapshot,
                 before_state=before_state,
                 after_state=target_state.value,
                 before_warehouse_id=before_warehouse_id,
                 before_site_id=before_site_id,
+                before_tunnel_id=before_tunnel_id,
                 before_line_id=before_line_id,
                 after_warehouse_id=inventory.warehouse_id,
                 after_site_id=inventory.site_id,
+                after_tunnel_id=inventory.tunnel_id,
                 after_line_id=inventory.current_line_id,
                 before_remaining_packages=before_remaining_packages,
                 after_remaining_packages=remaining_after,
+                trace_no=before_trace_no,
+                batch_no_snapshot=filling.batch_no,
                 operator_id=user_id,
                 occurred_at=current_time,
                 idempotency_key=page_object.idempotency_key,