arthexis 0.1.19__py3-none-any.whl → 0.1.20__py3-none-any.whl

ocpp/admin.py

@@ -16,6 +16,7 @@ from asgiref.sync import async_to_sync
 
 from .models import (
     Charger,
+    ChargerConfiguration,
     Simulator,
     MeterValue,
     Transaction,
@@ -108,6 +109,82 @@ class LogViewAdminMixin:
         return TemplateResponse(request, self.log_template_name, context)
 
 
+@admin.register(ChargerConfiguration)
+class ChargerConfigurationAdmin(admin.ModelAdmin):
+    list_display = ("charger_identifier", "connector_display", "created_at")
+    list_filter = ("connector_id",)
+    search_fields = ("charger_identifier",)
+    readonly_fields = (
+        "charger_identifier",
+        "connector_id",
+        "created_at",
+        "updated_at",
+        "linked_chargers",
+        "configuration_keys_display",
+        "unknown_keys_display",
+        "raw_payload_display",
+    )
+    fieldsets = (
+        (
+            None,
+            {
+                "fields": (
+                    "charger_identifier",
+                    "connector_id",
+                    "linked_chargers",
+                    "created_at",
+                    "updated_at",
+                )
+            },
+        ),
+        (
+            "Payload",
+            {
+                "fields": (
+                    "configuration_keys_display",
+                    "unknown_keys_display",
+                    "raw_payload_display",
+                )
+            },
+        ),
+    )
+
+    @admin.display(description="Connector")
+    def connector_display(self, obj):
+        if obj.connector_id is None:
+            return "All"
+        return obj.connector_id
+
+    @admin.display(description="Linked charge points")
+    def linked_chargers(self, obj):
+        if obj.pk is None:
+            return ""
+        linked = [charger.identity_slug() for charger in obj.chargers.all()]
+        if not linked:
+            return "-"
+        return ", ".join(sorted(linked))
+
+    def _render_json(self, data):
+        from django.utils.html import format_html
+
+        if not data:
+            return "-"
+        formatted = json.dumps(data, indent=2, ensure_ascii=False)
+        return format_html("<pre>{}</pre>", formatted)
+
+    @admin.display(description="configurationKey")
+    def configuration_keys_display(self, obj):
+        return self._render_json(obj.configuration_keys)
+
+    @admin.display(description="unknownKey")
+    def unknown_keys_display(self, obj):
+        return self._render_json(obj.unknown_keys)
+
+    @admin.display(description="Raw payload")
+    def raw_payload_display(self, obj):
+        return self._render_json(obj.raw_payload)
+
+
 @admin.register(Location)
 class LocationAdmin(EntityModelAdmin):
     form = LocationAdminForm
@@ -207,7 +284,7 @@ class ChargerAdmin(LogViewAdminMixin, EntityModelAdmin):
         ),
         (
             "Configuration",
-            {"fields": ("public_display", "require_rfid")},
+            {"fields": ("public_display", "require_rfid", "configuration")},
         ),
         (
             "References",
@@ -236,11 +313,12 @@ class ChargerAdmin(LogViewAdminMixin, EntityModelAdmin):
         "availability_request_status",
         "availability_request_status_at",
         "availability_request_details",
+        "configuration",
     )
     list_display = (
-        "charger_id",
+        "display_name_with_fallback",
         "connector_number",
-        "location_name",
+        "serial_number_display",
         "require_rfid_display",
         "public_display",
         "last_heartbeat",
@@ -349,6 +427,18 @@ class ChargerAdmin(LogViewAdminMixin, EntityModelAdmin):
                 return True
         return False
 
+    @admin.display(description="Display Name", ordering="display_name")
+    def display_name_with_fallback(self, obj):
+        if obj.display_name:
+            return obj.display_name
+        if obj.location:
+            return obj.location.name
+        return obj.charger_id
+
+    @admin.display(description="Serial Number", ordering="charger_id")
+    def serial_number_display(self, obj):
+        return obj.charger_id
+
     def location_name(self, obj):
         return obj.location.name if obj.location else ""
 
@@ -933,8 +1023,10 @@ class TransactionAdmin(EntityModelAdmin):
     change_list_template = "admin/ocpp/transaction/change_list.html"
     list_display = (
         "charger",
+        "connector_number",
         "account",
         "rfid",
+        "vid",
         "meter_start",
         "meter_stop",
         "start_time",
@@ -946,6 +1038,12 @@ class TransactionAdmin(EntityModelAdmin):
     date_hierarchy = "start_time"
     inlines = [MeterValueInline]
 
+    def connector_number(self, obj):
+        return obj.connector_id or ""
+
+    connector_number.short_description = "#"
+    connector_number.admin_order_field = "connector_id"
+
     def get_urls(self):
         urls = super().get_urls()
         custom = [

ocpp/consumers.py

@@ -20,7 +20,13 @@ from config.offline import requires_network
 from . import store
 from decimal import Decimal
 from django.utils.dateparse import parse_datetime
-from .models import Transaction, Charger, MeterValue, DataTransferMessage
+from .models import (
+    Transaction,
+    Charger,
+    ChargerConfiguration,
+    MeterValue,
+    DataTransferMessage,
+)
 from .reference_utils import host_is_local_loopback
 from .evcs_discovery import (
     DEFAULT_CONSOLE_PORT,
@@ -138,6 +144,18 @@ def _parse_ocpp_timestamp(value) -> datetime | None:
     return timestamp
 
 
+def _extract_vehicle_identifier(payload: dict) -> tuple[str, str]:
+    """Return normalized VID and VIN values from an OCPP message payload."""
+
+    raw_vid = payload.get("vid")
+    vid_value = str(raw_vid).strip() if raw_vid is not None else ""
+    raw_vin = payload.get("vin")
+    vin_value = str(raw_vin).strip() if raw_vin is not None else ""
+    if not vid_value and vin_value:
+        vid_value = vin_value
+    return vid_value, vin_value
+
+
 class SinkConsumer(AsyncWebsocketConsumer):
     """Accept any message without validation."""
 
@@ -283,11 +301,18 @@ class CSMSConsumer(AsyncWebsocketConsumer):
         """Return the energy account for the provided RFID if valid."""
         if not id_tag:
             return None
-        return await database_sync_to_async(
-            EnergyAccount.objects.filter(
-                rfids__rfid=id_tag.upper(), rfids__allowed=True
-            ).first
-        )()
+
+        def _resolve() -> EnergyAccount | None:
+            matches = CoreRFID.matching_queryset(id_tag).filter(allowed=True)
+            if not matches.exists():
+                return None
+            return (
+                EnergyAccount.objects.filter(rfids__in=matches)
+                .distinct()
+                .first()
+            )
+
+        return await database_sync_to_async(_resolve)()
 
     async def _ensure_rfid_seen(self, id_tag: str) -> CoreRFID | None:
         """Ensure an RFID record exists and update its last seen timestamp."""
@@ -726,6 +751,53 @@ class CSMSConsumer(AsyncWebsocketConsumer):
         task.add_done_callback(lambda _: setattr(self, "_consumption_task", None))
         self._consumption_task = task
 
+    def _persist_configuration_result(
+        self, payload: dict, connector_hint: int | str | None
+    ) -> ChargerConfiguration | None:
+        if not isinstance(payload, dict):
+            return None
+
+        connector_value: int | None = None
+        if connector_hint not in (None, ""):
+            try:
+                connector_value = int(connector_hint)
+            except (TypeError, ValueError):
+                connector_value = None
+
+        normalized_entries: list[dict[str, object]] = []
+        for entry in payload.get("configurationKey") or []:
+            if not isinstance(entry, dict):
+                continue
+            key = str(entry.get("key") or "")
+            normalized: dict[str, object] = {"key": key}
+            if "value" in entry:
+                normalized["value"] = entry.get("value")
+            normalized["readonly"] = bool(entry.get("readonly"))
+            normalized_entries.append(normalized)
+
+        unknown_values: list[str] = []
+        for value in payload.get("unknownKey") or []:
+            if value is None:
+                continue
+            unknown_values.append(str(value))
+
+        try:
+            raw_payload = json.loads(json.dumps(payload, ensure_ascii=False))
+        except (TypeError, ValueError):
+            raw_payload = payload
+
+        configuration = ChargerConfiguration.objects.create(
+            charger_identifier=self.charger_id,
+            connector_id=connector_value,
+            configuration_keys=normalized_entries,
+            unknown_keys=unknown_values,
+            raw_payload=raw_payload,
+        )
+        Charger.objects.filter(charger_id=self.charger_id).update(
+            configuration=configuration
+        )
+        return configuration
+
     async def _handle_call_result(self, message_id: str, payload: dict | None) -> None:
         metadata = store.pop_pending_call(message_id)
         if not metadata:
@@ -787,6 +859,17 @@ class CSMSConsumer(AsyncWebsocketConsumer):
                 f"GetConfiguration result: {payload_text}",
                 log_type="charger",
             )
+            configuration = await database_sync_to_async(
+                self._persist_configuration_result
+            )(payload_data, metadata.get("connector_id"))
+            if configuration:
+                if self.charger and self.charger.charger_id == self.charger_id:
+                    self.charger.configuration = configuration
+                if (
+                    self.aggregate_charger
+                    and self.aggregate_charger.charger_id == self.charger_id
+                ):
+                    self.aggregate_charger.configuration = configuration
             store.record_pending_call_result(
                 message_id,
                 metadata=metadata,
@@ -1338,8 +1421,13 @@ class CSMSConsumer(AsyncWebsocketConsumer):
                 reply_payload = {"currentTime": datetime.utcnow().isoformat() + "Z"}
                 now = timezone.now()
                 self.charger.last_heartbeat = now
+                if (
+                    self.aggregate_charger
+                    and self.aggregate_charger is not self.charger
+                ):
+                    self.aggregate_charger.last_heartbeat = now
                 await database_sync_to_async(
-                    Charger.objects.filter(pk=self.charger.pk).update
+                    Charger.objects.filter(charger_id=self.charger_id).update
                 )(last_heartbeat=now)
             elif action == "StatusNotification":
                 await self._assign_connector(payload.get("connectorId"))
@@ -1538,11 +1626,13 @@ class CSMSConsumer(AsyncWebsocketConsumer):
                         self._log_unlinked_rfid(tag.rfid)
                     start_timestamp = _parse_ocpp_timestamp(payload.get("timestamp"))
                     received_start = timezone.now()
+                    vid_value, vin_value = _extract_vehicle_identifier(payload)
                     tx_obj = await database_sync_to_async(Transaction.objects.create)(
                         charger=self.charger,
                         account=account,
                         rfid=(id_tag or ""),
-                        vin=(payload.get("vin") or ""),
+                        vid=vid_value,
+                        vin=vin_value,
                         connector_id=payload.get("connectorId"),
                         meter_start=payload.get("meterStart"),
                         start_time=start_timestamp or received_start,
@@ -1568,6 +1658,7 @@ class CSMSConsumer(AsyncWebsocketConsumer):
                     )()
                 if not tx_obj and tx_id is not None:
                     received_start = timezone.now()
+                    vid_value, vin_value = _extract_vehicle_identifier(payload)
                     tx_obj = await database_sync_to_async(Transaction.objects.create)(
                         pk=tx_id,
                         charger=self.charger,
@@ -1575,12 +1666,18 @@ class CSMSConsumer(AsyncWebsocketConsumer):
                         received_start_time=received_start,
                         meter_start=payload.get("meterStart")
                         or payload.get("meterStop"),
-                        vin=(payload.get("vin") or ""),
+                        vid=vid_value,
+                        vin=vin_value,
                     )
                 if tx_obj:
                     stop_timestamp = _parse_ocpp_timestamp(payload.get("timestamp"))
                     received_stop = timezone.now()
                     tx_obj.meter_stop = payload.get("meterStop")
+                    vid_value, vin_value = _extract_vehicle_identifier(payload)
+                    if vid_value:
+                        tx_obj.vid = vid_value
+                    if vin_value:
+                        tx_obj.vin = vin_value
                     tx_obj.stop_time = stop_timestamp or received_stop
                     tx_obj.received_stop_time = received_stop
                     await database_sync_to_async(tx_obj.save)()

ocpp/models.py

@@ -204,6 +204,16 @@ class Charger(Entity):
         related_name="chargers",
     )
     last_path = models.CharField(max_length=255, blank=True)
+    configuration = models.ForeignKey(
+        "ChargerConfiguration",
+        null=True,
+        blank=True,
+        on_delete=models.SET_NULL,
+        related_name="chargers",
+        help_text=_(
+            "Latest GetConfiguration response received from this charge point."
+        ),
+    )
     manager_node = models.ForeignKey(
         "nodes.Node",
         on_delete=models.SET_NULL,
@@ -585,6 +595,51 @@ class Charger(Entity):
         super().delete(*args, **kwargs)
 
 
+class ChargerConfiguration(models.Model):
+    """Persisted configuration package returned by a charge point."""
+
+    charger_identifier = models.CharField(_("Serial Number"), max_length=100)
+    connector_id = models.PositiveIntegerField(
+        _("Connector ID"),
+        null=True,
+        blank=True,
+        help_text=_("Connector that returned this configuration (if specified)."),
+    )
+    configuration_keys = models.JSONField(
+        default=list,
+        blank=True,
+        help_text=_("Entries from the configurationKey list."),
+    )
+    unknown_keys = models.JSONField(
+        default=list,
+        blank=True,
+        help_text=_("Keys returned in the unknownKey list."),
+    )
+    raw_payload = models.JSONField(
+        default=dict,
+        blank=True,
+        help_text=_("Raw payload returned by the GetConfiguration call."),
+    )
+    created_at = models.DateTimeField(auto_now_add=True)
+    updated_at = models.DateTimeField(auto_now=True)
+
+    class Meta:
+        ordering = ["-created_at"]
+        verbose_name = _("CP Configuration")
+        verbose_name_plural = _("CP Configurations")
+
+    def __str__(self) -> str:  # pragma: no cover - simple representation
+        connector = (
+            _("connector %(number)s") % {"number": self.connector_id}
+            if self.connector_id is not None
+            else _("all connectors")
+        )
+        return _("%(serial)s configuration (%(connector)s)") % {
+            "serial": self.charger_identifier,
+            "connector": connector,
+        }
+
+
 class Transaction(Entity):
     """Charging session data stored for each charger."""
 
@@ -599,7 +654,18 @@ class Transaction(Entity):
         blank=True,
         verbose_name=_("RFID"),
     )
-    vin = models.CharField(max_length=17, blank=True)
+    vid = models.CharField(
+        max_length=64,
+        blank=True,
+        default="",
+        verbose_name=_("VID"),
+        help_text=_("Vehicle identifier reported by the charger."),
+    )
+    vin = models.CharField(
+        max_length=17,
+        blank=True,
+        help_text=_("Deprecated. Use VID instead."),
+    )
     connector_id = models.PositiveIntegerField(null=True, blank=True)
     meter_start = models.IntegerField(null=True, blank=True)
     meter_stop = models.IntegerField(null=True, blank=True)
@@ -645,6 +711,22 @@ class Transaction(Entity):
         verbose_name = _("Transaction")
         verbose_name_plural = _("CP Transactions")
 
+    @property
+    def vehicle_identifier(self) -> str:
+        """Return the preferred vehicle identifier for this transaction."""
+
+        return (self.vid or self.vin or "").strip()
+
+    @property
+    def vehicle_identifier_source(self) -> str:
+        """Return which field supplies :pyattr:`vehicle_identifier`."""
+
+        if (self.vid or "").strip():
+            return "vid"
+        if (self.vin or "").strip():
+            return "vin"
+        return ""
+
     @property
     def kw(self) -> float:
         """Return consumed energy in kW for this session."""

ocpp/tasks.py

@@ -149,6 +149,10 @@ def send_daily_session_report() -> int:
         lines.append(f"   Account: {account}")
         if transaction.rfid:
             lines.append(f"   RFID: {transaction.rfid}")
+        identifier = transaction.vehicle_identifier
+        if identifier:
+            label = "VID" if transaction.vehicle_identifier_source == "vid" else "VIN"
+            lines.append(f"   {label}: {identifier}")
         if connector:
             lines.append(f"   {connector}")
         lines.append(

ocpp/test_export_import.py

@@ -111,6 +111,7 @@ class TransactionAdminExportImportTests(TestCase):
                     "charger": "C9",
                     "account": None,
                     "rfid": "",
+                    "vid": "",
                     "vin": "",
                     "meter_start": 0,
                     "meter_stop": 0,

ocpp/test_rfid.py

@@ -771,7 +771,9 @@ class RFIDLandingTests(TestCase):
         app = Application.objects.create(name="Ocpp")
         module = Module.objects.create(node_role=role, application=app, path="/ocpp/")
         module.create_landings()
-        self.assertTrue(module.landings.filter(path="/ocpp/rfid/").exists())
+        self.assertTrue(
+            module.landings.filter(path="/ocpp/rfid/validator/").exists()
+        )
 
 
 class ScannerTemplateTests(TestCase):

ocpp/tests.py

@@ -61,13 +61,14 @@ from config.asgi import application
 from .models import (
     Transaction,
     Charger,
+    ChargerConfiguration,
     Simulator,
     MeterReading,
     Location,
     DataTransferMessage,
 )
 from .consumers import CSMSConsumer
-from .views import dispatch_action
+from .views import dispatch_action, _transaction_rfid_details
 from .status_display import STATUS_BADGE_MAP
 from core.models import EnergyAccount, EnergyCredit, Reference, RFID, SecurityGroup
 from . import store
@@ -714,6 +715,13 @@ class CSMSConsumerTests(TransactionTestCase):
         connected, _ = await communicator.connect()
         self.assertTrue(connected)
 
+        await database_sync_to_async(Charger.objects.get_or_create)(
+            charger_id="CFGRES", connector_id=1
+        )
+        await database_sync_to_async(Charger.objects.get_or_create)(
+            charger_id="CFGRES", connector_id=2
+        )
+
         message_id = "cfg-result"
         payload = {
             "configurationKey": [
@@ -744,6 +752,31 @@ class CSMSConsumerTests(TransactionTestCase):
         )
         self.assertNotIn(message_id, store.pending_calls)
 
+        configuration = await database_sync_to_async(
+            lambda: ChargerConfiguration.objects.order_by("-created_at").first()
+        )()
+        self.assertIsNotNone(configuration)
+        self.assertEqual(configuration.charger_identifier, "CFGRES")
+        self.assertEqual(
+            configuration.configuration_keys,
+            [
+                {
+                    "key": "AllowOfflineTxForUnknownId",
+                    "value": "false",
+                    "readonly": True,
+                }
+            ],
+        )
+        self.assertEqual(configuration.unknown_keys, [])
+        config_ids = await database_sync_to_async(
+            lambda: set(
+                Charger.objects.filter(charger_id="CFGRES").values_list(
+                    "configuration_id", flat=True
+                )
+            )
+        )()
+        self.assertEqual(config_ids, {configuration.pk})
+
         await communicator.disconnect()
         store.clear_log(log_key, log_type="charger")
         store.clear_log(pending_key, log_type="charger")
@@ -1109,7 +1142,7 @@ class CSMSConsumerTests(TransactionTestCase):
 
         await communicator.disconnect()
 
-    async def test_vin_recorded(self):
+    async def test_vid_populated_from_vin(self):
         await database_sync_to_async(Charger.objects.create)(charger_id="VINREC")
         communicator = WebsocketCommunicator(application, "/VINREC/")
         connected, _ = await communicator.connect()
@@ -1124,7 +1157,29 @@ class CSMSConsumerTests(TransactionTestCase):
         tx = await database_sync_to_async(Transaction.objects.get)(
             pk=tx_id, charger__charger_id="VINREC"
         )
-        self.assertEqual(tx.vin, "WP0ZZZ11111111111")
+        self.assertEqual(tx.vid, "WP0ZZZ11111111111")
+        self.assertEqual(tx.vehicle_identifier, "WP0ZZZ11111111111")
+        self.assertEqual(tx.vehicle_identifier_source, "vid")
+
+        await communicator.disconnect()
+
+    async def test_vid_recorded(self):
+        await database_sync_to_async(Charger.objects.create)(charger_id="VIDREC")
+        communicator = WebsocketCommunicator(application, "/VIDREC/")
+        connected, _ = await communicator.connect()
+        self.assertTrue(connected)
+
+        await communicator.send_json_to(
+            [2, "1", "StartTransaction", {"meterStart": 1, "vid": "VID123456"}]
+        )
+        response = await communicator.receive_json_from()
+        tx_id = response[2]["transactionId"]
+
+        tx = await database_sync_to_async(Transaction.objects.get)(
+            pk=tx_id, charger__charger_id="VIDREC"
+        )
+        self.assertEqual(tx.vid, "VID123456")
+        self.assertEqual(tx.rfid, "")
 
         await communicator.disconnect()
 
@@ -2126,12 +2181,12 @@ class SimulatorLandingTests(TestCase):
     @skip("Navigation links unavailable in test environment")
     def test_simulator_app_link_in_nav(self):
         resp = self.client.get(reverse("pages:index"))
-        self.assertContains(resp, "/ocpp/")
-        self.assertNotContains(resp, "/ocpp/simulator/")
+        self.assertContains(resp, "/ocpp/cpms/dashboard/")
+        self.assertNotContains(resp, "/ocpp/evcs/simulator/")
         self.client.force_login(self.user)
         resp = self.client.get(reverse("pages:index"))
-        self.assertContains(resp, "/ocpp/")
-        self.assertContains(resp, "/ocpp/simulator/")
+        self.assertContains(resp, "/ocpp/cpms/dashboard/")
+        self.assertContains(resp, "/ocpp/evcs/simulator/")
 
     def test_cp_simulator_redirects_to_login(self):
         response = self.client.get(reverse("cp-simulator"))
@@ -3212,8 +3267,7 @@ class SimulatorAdminTests(TransactionTestCase):
         self.assertIsNotNone(aggregate.last_heartbeat)
         if previous_heartbeat:
             self.assertNotEqual(aggregate.last_heartbeat, previous_heartbeat)
-        if connector.last_heartbeat:
-            self.assertNotEqual(aggregate.last_heartbeat, connector.last_heartbeat)
+        self.assertEqual(connector.last_heartbeat, aggregate.last_heartbeat)
 
         await communicator.disconnect()
 
@@ -4009,6 +4063,43 @@ class TransactionKwTests(TestCase):
         self.assertEqual(tx.kw, 0.0)
 
 
+class TransactionIdentifierTests(TestCase):
+    def test_vehicle_identifier_prefers_vid(self):
+        charger = Charger.objects.create(charger_id="VIDPREF")
+        tx = Transaction.objects.create(
+            charger=charger,
+            start_time=timezone.now(),
+            vid="VID-123",
+            vin="VIN-456",
+        )
+        self.assertEqual(tx.vehicle_identifier, "VID-123")
+        self.assertEqual(tx.vehicle_identifier_source, "vid")
+
+    def test_vehicle_identifier_falls_back_to_vin(self):
+        charger = Charger.objects.create(charger_id="VINONLY")
+        tx = Transaction.objects.create(
+            charger=charger,
+            start_time=timezone.now(),
+            vin="WP0ZZZ00000000001",
+        )
+        self.assertEqual(tx.vehicle_identifier, "WP0ZZZ00000000001")
+        self.assertEqual(tx.vehicle_identifier_source, "vin")
+
+    def test_transaction_rfid_details_handles_vin(self):
+        charger = Charger.objects.create(charger_id="VINDET")
+        tx = Transaction.objects.create(
+            charger=charger,
+            start_time=timezone.now(),
+            vin="WAUZZZ00000000002",
+        )
+        details = _transaction_rfid_details(tx, cache={})
+        self.assertIsNotNone(details)
+        assert details is not None  # for type checkers
+        self.assertEqual(details["value"], "WAUZZZ00000000002")
+        self.assertEqual(details["display_label"], "VIN")
+        self.assertEqual(details["type"], "vin")
+
+
 class DispatchActionViewTests(TestCase):
     def setUp(self):
         self.client = Client()

ocpp/transactions_io.py

@@ -46,6 +46,7 @@ def export_transactions(
                 "charger": tx.charger.charger_id if tx.charger else None,
                 "account": tx.account_id,
                 "rfid": tx.rfid,
+                "vid": tx.vehicle_identifier,
                 "vin": tx.vin,
                 "meter_start": tx.meter_start,
                 "meter_stop": tx.meter_stop,
@@ -144,11 +145,18 @@ def import_transactions(data: dict) -> int:
             except ValidationError:
                 continue
             charger_map[serial] = charger
+        vid_value = tx.get("vid")
+        vin_value = tx.get("vin")
+        vid_text = str(vid_value).strip() if vid_value is not None else ""
+        vin_text = str(vin_value).strip() if vin_value is not None else ""
+        if not vid_text and vin_text:
+            vid_text = vin_text
         transaction = Transaction.objects.create(
             charger=charger,
             account_id=tx.get("account"),
             rfid=tx.get("rfid", ""),
-            vin=tx.get("vin", ""),
+            vid=vid_text,
+            vin=vin_text,
             meter_start=tx.get("meter_start"),
             meter_stop=tx.get("meter_stop"),
             voltage_start=tx.get("voltage_start"),