Merge pull request #15 from DocSystem/main

Calypso parser + read more data on Navigo Pass

CHANGELOG.md

@@ -16,6 +16,7 @@
 - Added Opal parser (Sydney (and surrounds), NSW, Australia)
 - Added ITSO parser (United Kingdom)
 
-## v0.4
+## v0.4
 
-- Updated Navigo parser (Paris, France)
+- Updated Navigo parser (Paris, France)
+  - Now use a global Calypso parser, with defined structures

README.md

@@ -36,7 +36,7 @@ This is a list of metro cards and transit systems that need support or have part
 - **App Author**: [@luu176](https://github.com/luu176)
 - **Charliecard Parser**: [@zacharyweiss](https://github.com/zacharyweiss)
 - **Rav-Kav Parser**: [@luu176](https://github.com/luu176)
-- **Navigo Parser**: [@luu176](https://github.com/luu176) and [@DocSystem](https://github.com/DocSystem)
+- **Navigo Parser**: [@luu176](https://github.com/luu176), [@DocSystem](https://github.com/DocSystem)
 - **Metromoney Parser**: [@Leptopt1los](https://github.com/Leptopt1los)
 - **Bip! Parser**: [@rbasoalto](https://github.com/rbasoalto) [@gornekich](https://github.com/gornekich)
 - **Clipper Parser**: [@ke6jjj](https://github.com/ke6jjj)

api/calypso/calypso_util.c

@@ -0,0 +1,247 @@
+#include <stdlib.h>
+#include <string.h>
+#include "calypso_util.h"
+
+CalypsoElement make_calypso_final_element(
+    const char* key,
+    int size,
+    const char* label,
+    CalypsoFinalType final_type) {
+    CalypsoElement final_element = {};
+
+    final_element.type = CALYPSO_ELEMENT_TYPE_FINAL;
+    final_element.final = malloc(sizeof(CalypsoFinalElement));
+    final_element.final->size = size;
+    final_element.final->final_type = final_type;
+    strncpy(final_element.final->key, key, 64);
+    strncpy(final_element.final->label, label, 64);
+
+    return final_element;
+}
+
+CalypsoElement make_calypso_bitmap_element(const char* key, int size, CalypsoElement* elements) {
+    CalypsoElement bitmap_element = {};
+
+    bitmap_element.type = CALYPSO_ELEMENT_TYPE_BITMAP;
+    bitmap_element.bitmap = malloc(sizeof(CalypsoBitmapElement));
+    bitmap_element.bitmap->size = size;
+    bitmap_element.bitmap->elements = malloc(size * sizeof(CalypsoElement));
+    for(int i = 0; i < size; i++) {
+        bitmap_element.bitmap->elements[i] = elements[i];
+    }
+    strncpy(bitmap_element.bitmap->key, key, 64);
+
+    return bitmap_element;
+}
+
+void free_calypso_element(CalypsoElement* element) {
+    if(element->type == CALYPSO_ELEMENT_TYPE_FINAL) {
+        free(element->final);
+    } else {
+        for(int i = 0; i < element->bitmap->size; i++) {
+            free_calypso_element(&element->bitmap->elements[i]);
+        }
+        free(element->bitmap->elements);
+        free(element->bitmap);
+    }
+}
+
+void free_calypso_structure(CalypsoApp* structure) {
+    for(int i = 0; i < structure->elements_size; i++) {
+        free_calypso_element(&structure->elements[i]);
+    }
+    free(structure->elements);
+    free(structure);
+}
+
+int* get_bit_positions(const char* binary_string, int* count) {
+    int length = strlen(binary_string);
+    int* positions = malloc(length * sizeof(int));
+    int pos_index = 0;
+
+    for(int i = 0; i < length; i++) {
+        if(binary_string[length - 1 - i] == '1') {
+            positions[pos_index++] = i;
+        }
+    }
+
+    *count = pos_index;
+    return positions;
+}
+
+int is_bit_present(int* positions, int count, int bit) {
+    for(int i = 0; i < count; i++) {
+        if(positions[i] == bit) {
+            return 1;
+        }
+    }
+    return 0;
+}
+
+bool is_calypso_subnode_present(
+    const char* binary_string,
+    const char* key,
+    CalypsoBitmapElement* bitmap) {
+    char bit_slice[bitmap->size + 1];
+    strncpy(bit_slice, binary_string, bitmap->size);
+    bit_slice[bitmap->size] = '\0';
+    int count = 0;
+    int* positions = get_bit_positions(bit_slice, &count);
+    int offset = bitmap->size;
+    for(int i = 0; i < count; i++) {
+        CalypsoElement* element = &bitmap->elements[positions[i]];
+        if(element->type == CALYPSO_ELEMENT_TYPE_FINAL) {
+            if(strcmp(element->final->key, key) == 0) {
+                return true;
+            }
+            offset += element->final->size;
+        } else {
+            if(strcmp(element->bitmap->key, key) == 0) {
+                return true;
+            }
+            int sub_binary_string_size = element->bitmap->size;
+            char bit_slice[sub_binary_string_size + 1];
+            strncpy(bit_slice, binary_string, sub_binary_string_size);
+            bit_slice[sub_binary_string_size] = '\0';
+            if(is_calypso_subnode_present(binary_string + offset, key, element->bitmap)) {
+                return true;
+            }
+            offset += element->bitmap->size;
+        }
+    }
+    return false;
+}
+
+bool is_calypso_node_present(const char* binary_string, const char* key, CalypsoApp* structure) {
+    int offset = 0;
+    for(int i = 0; i < structure->elements_size; i++) {
+        if(structure->elements[i].type == CALYPSO_ELEMENT_TYPE_FINAL) {
+            if(strcmp(structure->elements[i].final->key, key) == 0) {
+                return true;
+            }
+            offset += structure->elements[i].final->size;
+        } else {
+            if(strcmp(structure->elements[i].bitmap->key, key) == 0) {
+                return true;
+            }
+            int sub_binary_string_size = structure->elements[i].bitmap->size;
+            char bit_slice[sub_binary_string_size + 1];
+            strncpy(bit_slice, binary_string, sub_binary_string_size);
+            bit_slice[sub_binary_string_size] = '\0';
+            if(is_calypso_subnode_present(
+                   binary_string + offset, key, structure->elements[i].bitmap)) {
+                return true;
+            }
+            offset += structure->elements[i].bitmap->size;
+        }
+    }
+    return false;
+}
+
+int get_calypso_subnode_offset(
+    const char* binary_string,
+    const char* key,
+    CalypsoBitmapElement* bitmap,
+    bool* found) {
+    char bit_slice[bitmap->size + 1];
+    strncpy(bit_slice, binary_string, bitmap->size);
+    bit_slice[bitmap->size] = '\0';
+
+    int count = 0;
+    int* positions = get_bit_positions(bit_slice, &count);
+
+    int count_offset = bitmap->size;
+    for(int i = 0; i < count; i++) {
+        CalypsoElement element = bitmap->elements[positions[i]];
+        if(element.type == CALYPSO_ELEMENT_TYPE_FINAL) {
+            if(strcmp(element.final->key, key) == 0) {
+                *found = true;
+                free(positions);
+                return count_offset;
+            }
+            count_offset += element.final->size;
+        } else {
+            if(strcmp(element.bitmap->key, key) == 0) {
+                *found = true;
+                free(positions);
+                return count_offset;
+            }
+            count_offset += get_calypso_subnode_offset(
+                binary_string + count_offset, key, element.bitmap, found);
+            if(*found) {
+                free(positions);
+                return count_offset;
+            }
+        }
+    }
+    free(positions);
+    return count_offset;
+}
+
+int get_calypso_node_offset(const char* binary_string, const char* key, CalypsoApp* structure) {
+    int count = 0;
+    bool found = false;
+    for(int i = 0; i < structure->elements_size; i++) {
+        if(structure->elements[i].type == CALYPSO_ELEMENT_TYPE_FINAL) {
+            if(strcmp(structure->elements[i].final->key, key) == 0) {
+                return count;
+            }
+            count += structure->elements[i].final->size;
+        } else {
+            if(strcmp(structure->elements[i].bitmap->key, key) == 0) {
+                return count;
+            }
+            int sub_binary_string_size = structure->elements[i].bitmap->size;
+            char bit_slice[sub_binary_string_size + 1];
+            strncpy(bit_slice, binary_string + count, sub_binary_string_size);
+            bit_slice[sub_binary_string_size] = '\0';
+            count += get_calypso_subnode_offset(
+                binary_string + count, key, structure->elements[i].bitmap, &found);
+            if(found) {
+                return count;
+            }
+        }
+    }
+    return 0;
+}
+
+int get_calypso_subnode_size(const char* key, CalypsoElement* element) {
+    if(element->type == CALYPSO_ELEMENT_TYPE_FINAL) {
+        if(strcmp(element->final->key, key) == 0) {
+            return element->final->size;
+        }
+    } else {
+        if(strcmp(element->bitmap->key, key) == 0) {
+            return element->bitmap->size;
+        }
+        for(int i = 0; i < element->bitmap->size; i++) {
+            int size = get_calypso_subnode_size(key, &element->bitmap->elements[i]);
+            if(size != 0) {
+                return size;
+            }
+        }
+    }
+    return 0;
+}
+
+int get_calypso_node_size(const char* key, CalypsoApp* structure) {
+    for(int i = 0; i < structure->elements_size; i++) {
+        if(structure->elements[i].type == CALYPSO_ELEMENT_TYPE_FINAL) {
+            if(strcmp(structure->elements[i].final->key, key) == 0) {
+                return structure->elements[i].final->size;
+            }
+        } else {
+            if(strcmp(structure->elements[i].bitmap->key, key) == 0) {
+                return structure->elements[i].bitmap->size;
+            }
+            for(int j = 0; j < structure->elements[i].bitmap->size; j++) {
+                int size =
+                    get_calypso_subnode_size(key, &structure->elements[i].bitmap->elements[j]);
+                if(size != 0) {
+                    return size;
+                }
+            }
+        }
+    }
+    return 0;
+}

api/calypso/calypso_util.h

@@ -0,0 +1,80 @@
+#include <stdbool.h>
+
+#ifndef CALYPSO_UTIL_H
+#define CALYPSO_UTIL_H
+
+typedef enum {
+    CALYPSO_APP_CONTRACT,
+} CalypsoAppType;
+
+typedef enum {
+    CALYPSO_FINAL_TYPE_UNKNOWN,
+    CALYPSO_FINAL_TYPE_NUMBER,
+    CALYPSO_FINAL_TYPE_DATE,
+    CALYPSO_FINAL_TYPE_TIME,
+    CALYPSO_FINAL_TYPE_PAY_METHOD,
+    CALYPSO_FINAL_TYPE_AMOUNT,
+    CALYPSO_FINAL_TYPE_SERVICE_PROVIDER,
+    CALYPSO_FINAL_TYPE_ZONES,
+    CALYPSO_FINAL_TYPE_TARIFF,
+    CALYPSO_FINAL_TYPE_NETWORK_ID,
+    CALYPSO_FINAL_TYPE_TRANSPORT_TYPE,
+    CALYPSO_FINAL_TYPE_CARD_STATUS,
+} CalypsoFinalType;
+
+typedef enum {
+    CALYPSO_ELEMENT_TYPE_BITMAP,
+    CALYPSO_ELEMENT_TYPE_FINAL
+} CalypsoElementType;
+
+typedef struct CalypsoFinalElement_t CalypsoFinalElement;
+typedef struct CalypsoBitmapElement_t CalypsoBitmapElement;
+
+typedef struct {
+    CalypsoElementType type;
+    union {
+        CalypsoFinalElement* final;
+        CalypsoBitmapElement* bitmap;
+    };
+} CalypsoElement;
+
+struct CalypsoFinalElement_t {
+    char key[64];
+    int size;
+    char label[64];
+    CalypsoFinalType final_type;
+};
+
+struct CalypsoBitmapElement_t {
+    char key[64];
+    int size;
+    CalypsoElement* elements;
+};
+
+typedef struct {
+    CalypsoAppType type;
+    CalypsoElement* elements;
+    int elements_size;
+} CalypsoApp;
+
+CalypsoElement make_calypso_final_element(
+    const char* key,
+    int size,
+    const char* label,
+    CalypsoFinalType final_type);
+
+CalypsoElement make_calypso_bitmap_element(const char* key, int size, CalypsoElement* elements);
+
+void free_calypso_structure(CalypsoApp* structure);
+
+int* get_bit_positions(const char* binary_string, int* count);
+
+int is_bit_present(int* positions, int count, int bit);
+
+bool is_calypso_node_present(const char* binary_string, const char* key, CalypsoApp* structure);
+
+int get_calypso_node_offset(const char* binary_string, const char* key, CalypsoApp* structure);
+
+int get_calypso_node_size(const char* key, CalypsoApp* structure);
+
+#endif // CALYPSO_UTIL_H

api/calypso/cards/navigo.c

@@ -0,0 +1,379 @@
+#include <stdlib.h>
+#include "navigo.h"
+
+CalypsoApp* get_navigo_contract_structure() {
+    CalypsoApp* NavigoContractStructure = malloc(sizeof(CalypsoApp));
+    if(!NavigoContractStructure) {
+        return NULL;
+    }
+
+    int app_elements_count = 1;
+
+    NavigoContractStructure->type = CALYPSO_APP_CONTRACT;
+    NavigoContractStructure->elements = malloc(app_elements_count * sizeof(CalypsoElement));
+    NavigoContractStructure->elements_size = app_elements_count;
+
+    NavigoContractStructure->elements[0] = make_calypso_bitmap_element(
+        "Contract",
+        20,
+        (CalypsoElement[]){
+            make_calypso_final_element(
+                "ContractNetworkId", 24, "Identification du réseau", CALYPSO_FINAL_TYPE_UNKNOWN),
+
+            make_calypso_final_element(
+                "ContractProvider",
+                8,
+                "Identification de l’exploitant",
+                CALYPSO_FINAL_TYPE_UNKNOWN),
+            make_calypso_final_element(
+                "ContractTariff", 16, "Code tarif", CALYPSO_FINAL_TYPE_TARIFF),
+
+            make_calypso_final_element(
+                "ContractSerialNumber", 32, "Numéro TCN", CALYPSO_FINAL_TYPE_UNKNOWN),
+
+            make_calypso_bitmap_element(
+                "ContractCustomerInfoBitmap",
+                2,
+                (CalypsoElement[]){
+                    make_calypso_final_element(
+                        "ContractCustomerProfile",
+                        6,
+                        "Statut du titulaire ou Taux de réduction applicable",
+                        CALYPSO_FINAL_TYPE_UNKNOWN),
+                    make_calypso_final_element(
+                        "ContractCustomerNumber",
+                        32,
+                        "Numéro de client",
+                        CALYPSO_FINAL_TYPE_UNKNOWN),
+                }),
+
+            make_calypso_bitmap_element(
+                "ContractPassengerInfoBitmap",
+                2,
+                (CalypsoElement[]){
+                    make_calypso_final_element(
+                        "ContractPassengerClass",
+                        8,
+                        "Classe de service des voyageurs",
+                        CALYPSO_FINAL_TYPE_UNKNOWN),
+                    make_calypso_final_element(
+                        "ContractPassengerTotal",
+                        8,
+                        "Nombre total de voyageurs",
+                        CALYPSO_FINAL_TYPE_UNKNOWN),
+                }),
+
+            make_calypso_final_element(
+                "ContractVehicleClassAllowed",
+                6,
+                "Classes de véhicule autorisé",
+                CALYPSO_FINAL_TYPE_UNKNOWN),
+
+            make_calypso_final_element(
+                "ContractPaymentPointer",
+                32,
+                "Pointeurs sur les événements de paiement",
+                CALYPSO_FINAL_TYPE_UNKNOWN),
+
+            make_calypso_final_element(
+                "ContractPayMethod", 11, "Code mode de paiement", CALYPSO_FINAL_TYPE_PAY_METHOD),
+
+            make_calypso_final_element(
+                "ContractServices", 16, "Services autorisés", CALYPSO_FINAL_TYPE_UNKNOWN),
+
+            make_calypso_final_element(
+                "ContractPriceAmount", 16, "Montant total", CALYPSO_FINAL_TYPE_AMOUNT),
+
+            make_calypso_final_element(
+                "ContractPriceUnit", 16, "Code de monnaie", CALYPSO_FINAL_TYPE_UNKNOWN),
+
+            make_calypso_bitmap_element(
+                "ContractRestrictionBitmap",
+                7,
+                (CalypsoElement[]){
+                    make_calypso_final_element(
+                        "ContractRestrictStart", 11, "", CALYPSO_FINAL_TYPE_UNKNOWN),
+                    make_calypso_final_element(
+                        "ContractRestrictEnd", 11, "", CALYPSO_FINAL_TYPE_UNKNOWN),
+                    make_calypso_final_element(
+                        "ContractRestrictDay", 8, "", CALYPSO_FINAL_TYPE_UNKNOWN),
+                    make_calypso_final_element(
+                        "ContractRestrictTimeCode", 8, "", CALYPSO_FINAL_TYPE_UNKNOWN),
+                    make_calypso_final_element(
+                        "ContractRestrictCode",
+                        8,
+                        "Code de restriction",
+                        CALYPSO_FINAL_TYPE_UNKNOWN),
+                    make_calypso_final_element(
+                        "ContractRestrictProduct",
+                        16,
+                        "Produit de restriction",
+                        CALYPSO_FINAL_TYPE_UNKNOWN),
+                    make_calypso_final_element(
+                        "ContractRestrictLocation",
+                        16,
+                        "Référence du lieu de restriction",
+                        CALYPSO_FINAL_TYPE_UNKNOWN),
+                }),
+
+            make_calypso_bitmap_element(
+                "ContractValidityInfoBitmap",
+                9,
+                (CalypsoElement[]){
+                    make_calypso_final_element(
+                        "ContractValidityStartDate",
+                        14,
+                        "Date de début de validité",
+                        CALYPSO_FINAL_TYPE_DATE),
+                    make_calypso_final_element(
+                        "ContractValidityStartTime",
+                        11,
+                        "Heure de début de validité",
+                        CALYPSO_FINAL_TYPE_TIME),
+                    make_calypso_final_element(
+                        "ContractValidityEndDate",
+                        14,
+                        "Date de fin de validité",
+                        CALYPSO_FINAL_TYPE_DATE),
+                    make_calypso_final_element(
+                        "ContractValidityEndTime",
+                        11,
+                        "Heure de fin de validité",
+                        CALYPSO_FINAL_TYPE_TIME),
+                    make_calypso_final_element(
+                        "ContractValidityDuration",
+                        8,
+                        "Durée de validité",
+                        CALYPSO_FINAL_TYPE_UNKNOWN),
+                    make_calypso_final_element(
+                        "ContractValidityLimiteDate",
+                        14,
+                        "Date limite de première utilisation",
+                        CALYPSO_FINAL_TYPE_DATE),
+                    make_calypso_final_element(
+                        "ContractValidityZones",
+                        8,
+                        "Numéros des zones autorisées",
+                        CALYPSO_FINAL_TYPE_ZONES),
+                    make_calypso_final_element(
+                        "ContractValidityJourneys",
+                        16,
+                        "Nombre de voyages autorisés",
+                        CALYPSO_FINAL_TYPE_UNKNOWN),
+                    make_calypso_final_element(
+                        "ContractPeriodJourneys",
+                        16,
+                        "Nombre de voyages autorisés par période",
+                        CALYPSO_FINAL_TYPE_UNKNOWN),
+                }),
+
+            make_calypso_bitmap_element(
+                "ContractJourneyData",
+                8,
+                (CalypsoElement[]){
+                    make_calypso_final_element(
+                        "ContractJourneyOrigin",
+                        16,
+                        "Code lieu d’origine",
+                        CALYPSO_FINAL_TYPE_UNKNOWN),
+                    make_calypso_final_element(
+                        "ContractJourneyDestination",
+                        16,
+                        "Code lieu de destination",
+                        CALYPSO_FINAL_TYPE_UNKNOWN),
+                    make_calypso_final_element(
+                        "ContractJourneyRouteNumbers",
+                        16,
+                        "Numéros des lignes autorisées",
+                        CALYPSO_FINAL_TYPE_UNKNOWN),
+                    make_calypso_final_element(
+                        "ContractJourneyRouteVariants",
+                        8,
+                        "Variantes aux numéros des lignes autorisées",
+                        CALYPSO_FINAL_TYPE_UNKNOWN),
+                    make_calypso_final_element(
+                        "ContractJourneyRun", 16, "Référence du voyage", CALYPSO_FINAL_TYPE_UNKNOWN),
+                    make_calypso_final_element(
+                        "ContractJourneyVia", 16, "Code lieu du via", CALYPSO_FINAL_TYPE_UNKNOWN),
+                    make_calypso_final_element(
+                        "ContractJourneyDistance", 16, "Distance", CALYPSO_FINAL_TYPE_UNKNOWN),
+                    make_calypso_final_element(
+                        "ContractJourneyInterchanges",
+                        8,
+                        "Nombre de correspondances autorisées",
+                        CALYPSO_FINAL_TYPE_UNKNOWN),
+                }),
+
+            make_calypso_bitmap_element(
+                "ContractSaleData",
+                4,
+                (CalypsoElement[]){
+                    make_calypso_final_element(
+                        "ContractValiditySaleDate", 14, "Date de vente", CALYPSO_FINAL_TYPE_DATE),
+                    make_calypso_final_element(
+                        "ContractValiditySaleTime", 11, "Heure de vente", CALYPSO_FINAL_TYPE_TIME),
+                    make_calypso_final_element(
+                        "ContractValiditySaleAgent",
+                        8,
+                        "Identification de l’exploitant de vente",
+                        CALYPSO_FINAL_TYPE_SERVICE_PROVIDER),
+                    make_calypso_final_element(
+                        "ContractValiditySaleDevice",
+                        16,
+                        "Identification du terminal de vente",
+                        CALYPSO_FINAL_TYPE_UNKNOWN),
+                }),
+
+            make_calypso_final_element(
+                "ContractStatus", 8, "État du contrat", CALYPSO_FINAL_TYPE_UNKNOWN),
+
+            make_calypso_final_element(
+                "ContractLoyaltyPoints",
+                16,
+                "Nombre de points de fidélité",
+                CALYPSO_FINAL_TYPE_NUMBER),
+
+            make_calypso_final_element(
+                "ContractAuthenticator",
+                16,
+                "Code de contrôle de l’intégrité des données",
+                CALYPSO_FINAL_TYPE_UNKNOWN),
+
+            make_calypso_final_element(
+                "ContractData(0..255)", 0, "Données complémentaires", CALYPSO_FINAL_TYPE_UNKNOWN),
+        });
+
+    return NavigoContractStructure;
+}
+
+CalypsoApp* get_navigo_event_structure() {
+    CalypsoApp* NavigoEventStructure = malloc(sizeof(CalypsoApp));
+    if(!NavigoEventStructure) {
+        return NULL;
+    }
+
+    int app_elements_count = 3;
+
+    NavigoEventStructure->type = CALYPSO_APP_CONTRACT;
+    NavigoEventStructure->elements = malloc(app_elements_count * sizeof(CalypsoElement));
+    NavigoEventStructure->elements_size = app_elements_count;
+
+    NavigoEventStructure->elements[0] = make_calypso_final_element(
+        "EventDateStamp", 14, "Date de l’événement", CALYPSO_FINAL_TYPE_DATE);
+
+    NavigoEventStructure->elements[1] = make_calypso_final_element(
+        "EventTimeStamp", 11, "Heure de l’événement", CALYPSO_FINAL_TYPE_TIME);
+
+    NavigoEventStructure->elements[2] = make_calypso_bitmap_element(
+        "EventBitmap",
+        28,
+        (CalypsoElement[]){
+            make_calypso_final_element(
+                "EventDisplayData", 8, "Données pour l’affichage", CALYPSO_FINAL_TYPE_UNKNOWN),
+            make_calypso_final_element("EventNetworkId", 24, "Réseau", CALYPSO_FINAL_TYPE_NUMBER),
+            make_calypso_final_element(
+                "EventCode", 8, "Nature de l’événement", CALYPSO_FINAL_TYPE_UNKNOWN),
+            make_calypso_final_element(
+                "EventResult", 8, "Code Résultat", CALYPSO_FINAL_TYPE_UNKNOWN),
+            make_calypso_final_element(
+                "EventServiceProvider",
+                8,
+                "Identité de l’exploitant",
+                CALYPSO_FINAL_TYPE_SERVICE_PROVIDER),
+            make_calypso_final_element(
+                "EventNotokCounter", 8, "Compteur événements anormaux", CALYPSO_FINAL_TYPE_UNKNOWN),
+            make_calypso_final_element(
+                "EventSerialNumber",
+                24,
+                "Numéro de série de l’événement",
+                CALYPSO_FINAL_TYPE_UNKNOWN),
+            make_calypso_final_element(
+                "EventDestination", 16, "Destination de l’usager", CALYPSO_FINAL_TYPE_UNKNOWN),
+            make_calypso_final_element(
+                "EventLocationId", 16, "Lieu de l’événement", CALYPSO_FINAL_TYPE_UNKNOWN),
+            make_calypso_final_element(
+                "EventLocationGate", 8, "Identification du passage", CALYPSO_FINAL_TYPE_UNKNOWN),
+            make_calypso_final_element(
+                "EventDevice", 16, "Identificateur de l’équipement", CALYPSO_FINAL_TYPE_UNKNOWN),
+            make_calypso_final_element(
+                "EventRouteNumber", 16, "Référence de la ligne", CALYPSO_FINAL_TYPE_UNKNOWN),
+            make_calypso_final_element(
+                "EventRouteVariant",
+                8,
+                "Référence d’une variante de la ligne",
+                CALYPSO_FINAL_TYPE_UNKNOWN),
+            make_calypso_final_element(
+                "EventJourneyRun", 16, "Référence de la mission", CALYPSO_FINAL_TYPE_NUMBER),
+            make_calypso_final_element(
+                "EventVehicleId", 16, "Identificateur du véhicule", CALYPSO_FINAL_TYPE_NUMBER),
+            make_calypso_final_element(
+                "EventVehicleClass", 8, "Type de véhicule utilisé", CALYPSO_FINAL_TYPE_UNKNOWN),
+            make_calypso_final_element(
+                "EventLocationType",
+                5,
+                "Type d’endroit (gare, arrêt de bus), ",
+                CALYPSO_FINAL_TYPE_UNKNOWN),
+            make_calypso_final_element(
+                "EventEmployee", 240, "Code de l’employé impliqué", CALYPSO_FINAL_TYPE_UNKNOWN),
+            make_calypso_final_element(
+                "EventLocationReference",
+                16,
+                "Référence du lieu de l’événement",
+                CALYPSO_FINAL_TYPE_UNKNOWN),
+            make_calypso_final_element(
+                "EventJourneyInterchanges",
+                8,
+                "Nombre de correspondances",
+                CALYPSO_FINAL_TYPE_UNKNOWN),
+            make_calypso_final_element(
+                "EventPeriodJourneys", 16, "Nombre de voyage effectué", CALYPSO_FINAL_TYPE_UNKNOWN),
+            make_calypso_final_element(
+                "EventTotalJourneys",
+                16,
+                "Nombre total de voyage autorisé",
+                CALYPSO_FINAL_TYPE_UNKNOWN),
+            make_calypso_final_element(
+                "EventJourneyDistance", 16, "Distance parcourue", CALYPSO_FINAL_TYPE_UNKNOWN),
+            make_calypso_final_element(
+                "EventPriceAmount",
+                16,
+                "Montant en jeu lors de l’événement",
+                CALYPSO_FINAL_TYPE_UNKNOWN),
+            make_calypso_final_element(
+                "EventPriceUnit", 16, "Unité de montant en jeu", CALYPSO_FINAL_TYPE_UNKNOWN),
+            make_calypso_final_element(
+                "EventContractPointer",
+                5,
+                "Référence du contrat concerné",
+                CALYPSO_FINAL_TYPE_NUMBER),
+            make_calypso_final_element(
+                "EventAuthenticator", 16, "Code de sécurité", CALYPSO_FINAL_TYPE_UNKNOWN),
+
+            make_calypso_bitmap_element(
+                "EventData",
+                5,
+                (CalypsoElement[]){
+                    make_calypso_final_element(
+                        "EventDataDateFirstStamp",
+                        14,
+                        "Date de la première montée",
+                        CALYPSO_FINAL_TYPE_DATE),
+                    make_calypso_final_element(
+                        "EventDataTimeFirstStamp",
+                        11,
+                        "Heure de la première montée",
+                        CALYPSO_FINAL_TYPE_TIME),
+                    make_calypso_final_element(
+                        "EventDataSimulation",
+                        1,
+                        "Dernière validation (0=normal, 1=dégradé), ",
+                        CALYPSO_FINAL_TYPE_UNKNOWN),
+                    make_calypso_final_element(
+                        "EventDataTrip", 2, "Tronçon", CALYPSO_FINAL_TYPE_UNKNOWN),
+                    make_calypso_final_element(
+                        "EventDataRouteDirection", 2, "Sens", CALYPSO_FINAL_TYPE_UNKNOWN),
+                }),
+        });
+
+    return NavigoEventStructure;
+}

api/calypso/cards/navigo.h

@@ -0,0 +1,10 @@
+#include "../calypso_util.h"
+
+#ifndef NAVIGO_STRUCTURES_H
+#define NAVIGO_STRUCTURES_H
+
+CalypsoApp* get_navigo_contract_structure();
+
+CalypsoApp* get_navigo_event_structure();
+
+#endif // NAVIGO_STRUCTURES_H

application.fam

@@ -5,7 +5,7 @@ App(
     entry_point="metroflip",
     stack_size=2 * 1024,
     fap_category="NFC",
-    fap_version="0.3.1",
+    fap_version="0.4",
     fap_icon="icon.png",
     fap_description="An implementation of metrodroid on the flipper",
     fap_author="luu176",

scenes/metroflip_scene_navigo.c

@@ -1,6 +1,7 @@
 #include "../metroflip_i.h"
 #include <datetime.h>
 #include <dolphin/dolphin.h>
+#include <notification/notification_messages.h>
 #include <locale/locale.h>
 #include "navigo.h"
 
@@ -8,45 +9,6 @@
 
 #define TAG "Metroflip:Scene:Navigo"
 
-int eventSizes[] = {8,  24, 8, 8,   8,  8, 24, 16, 16, 8,  16, 16, 8,  16,
-                    16, 8,  5, 240, 16, 8, 16, 16, 16, 16, 16, 5,  16, 5};
-
-int* get_bit_positions(const char* binary_string, int* count) {
-    int length = strlen(binary_string);
-    int* positions = malloc(length * sizeof(int));
-    int pos_index = 0;
-
-    for(int i = 0; i < length; i++) {
-        if(binary_string[length - 1 - i] == '1') {
-            positions[pos_index++] = i - 1;
-        }
-    }
-
-    *count = pos_index;
-    return positions;
-}
-
-int is_event_present(int* array, int size, int number) {
-    for(int i = 0; i < size; i++) {
-        if(array[i] == number) {
-            return 1;
-        }
-    }
-    return 0;
-}
-
-int check_events(int* array, int size, int number) {
-    int total = 0;
-
-    for(int i = 0; i < size; i++) {
-        if(array[i] < number) {
-            total += eventSizes[array[i]];
-        }
-    }
-
-    return total + 53;
-}
-
 int select_new_app(
     int new_app,
     BitBuffer* tx_buffer,
@@ -153,6 +115,10 @@ const char* get_service_provider(int provider) {
         return "SNCF";
     case 3:
         return "RATP";
+    case 4:
+        return "IDF Mobilites";
+    case 10:
+        return "IDF Mobilites";
     case 115:
         return "CSO (VEOLIA)";
     case 116:
@@ -189,10 +155,73 @@ const char* get_transition_type(int transition) {
     case 15:
         return "Invalidation";
     default: {
-        char* transition_str = malloc(13);
-        snprintf(transition_str, 13, "Unknown (%d)", transition);
-        return transition_str;
+        return "Unknown";
+    }
     }
+}
+
+const char* get_navigo_type(int type) {
+    switch(type) {
+    case NAVIGO_EASY:
+        return "Navigo Easy";
+    case NAVIGO_DECOUVERTE:
+        return "Navigo Decouverte";
+    case NAVIGO_STANDARD:
+        return "Navigo Standard";
+    case NAVIGO_INTEGRAL:
+        return "Navigo Integral";
+    case IMAGINE_R:
+        return "Imagine R";
+    default:
+        return "Navigo Inconnu";
+    }
+}
+
+const char* get_tariff(int tariff) {
+    switch(tariff) {
+    case 0x0002:
+        return "Navigo Annuel";
+    case 0x0004:
+        return "Imagine R Junior";
+    case 0x0005:
+        return "Imagine R Etudiant";
+    case 0x000D:
+        return "Navigo Jeunes Week-end";
+    case 0x1000:
+        return "Navigo Liberte+";
+    case 0x5000:
+        return "Navigo Easy";
+    default:
+        return "Inconnu";
+    }
+}
+
+const char* get_pay_method(int pay_method) {
+    switch(pay_method) {
+    case 0x30:
+        return "Apple Pay";
+    case 0x80:
+        return "Debit PME";
+    case 0x90:
+        return "Espece";
+    case 0xA0:
+        return "Cheque mobilite";
+    case 0xB3:
+        return "Carte de paiement";
+    case 0xA4:
+        return "Cheque";
+    case 0xA5:
+        return "Cheque vacance";
+    case 0xB7:
+        return "Telepaiement";
+    case 0xD0:
+        return "Telereglement";
+    case 0xD7:
+        return "Bon de caisse, Versement prealable, Bon d’echange, Bon Voyage";
+    case 0xD9:
+        return "Bon de reduction";
+    default:
+        return "Inconnu";
     }
 }
 
@@ -293,17 +322,23 @@ void show_event_info(NavigoCardEvent* event, FuriString* parsed_data) {
         if(event->route_number_available) {
             furi_string_cat_printf(
                 parsed_data,
-                "RER %c\nStation : %s\n",
+                "RER %c\n%s\n",
                 (65 + event->route_number - 17),
-                get_train_station(event->station_group_id, event->station_id));
+                get_transition_type(event->transition));
         } else {
             furi_string_cat_printf(
                 parsed_data,
-                "%s %s\nStation : %s\n",
+                "%s %s\n%s\n",
                 get_transport_type(event->transport_type),
                 get_train_line(event->station_group_id),
-                get_train_station(event->station_group_id, event->station_id));
+                get_transition_type(event->transition));
         }
+        furi_string_cat_printf(
+            parsed_data, "Transporteur : %s\n", get_service_provider(event->service_provider));
+        furi_string_cat_printf(
+            parsed_data,
+            "Station : %s\n",
+            get_train_station(event->station_group_id, event->station_id));
         if(event->route_number_available) {
             furi_string_cat_printf(parsed_data, "Route : %d\n", event->route_number);
         }
@@ -354,11 +389,55 @@ void show_event_info(NavigoCardEvent* event, FuriString* parsed_data) {
     }
 }
 
-void show_contract_info(NavigoCardContract* contract, FuriString* parsed_data) {
-    furi_string_cat_printf(parsed_data, "Balance : %.2f EUR\n", (double)contract->balance);
-    furi_string_cat_printf(parsed_data, "Debut de validite:\n");
-    locale_format_datetime_cat(parsed_data, &contract->start_dt, false);
+void show_contract_info(NavigoCardContract* contract, int ticket_count, FuriString* parsed_data) {
+    furi_string_cat_printf(parsed_data, "Type : %s\n", get_tariff(contract->tariff));
+    if(contract->serial_number_available) {
+        furi_string_cat_printf(parsed_data, "Numero TCN : %d\n", contract->serial_number);
+    }
+    if(contract->pay_method_available) {
+        furi_string_cat_printf(
+            parsed_data, "Methode de paiement : %s\n", get_pay_method(contract->pay_method));
+    }
+    if(contract->price_amount_available) {
+        furi_string_cat_printf(parsed_data, "Montant : %.2f EUR\n", contract->price_amount);
+    }
+    if(contract->tariff == 0x5000) {
+        furi_string_cat_printf(parsed_data, "Titres restants : %d\n", ticket_count);
+    }
+    if(contract->end_date_available) {
+        furi_string_cat_printf(parsed_data, "Valide\ndu : ");
+        locale_format_datetime_cat(parsed_data, &contract->start_date, false);
+        furi_string_cat_printf(parsed_data, "\nau : ");
+        locale_format_datetime_cat(parsed_data, &contract->end_date, false);
+        furi_string_cat_printf(parsed_data, "\n");
+    } else {
+        furi_string_cat_printf(parsed_data, "Valide a partir du\n");
+        locale_format_datetime_cat(parsed_data, &contract->start_date, false);
+        furi_string_cat_printf(parsed_data, "\n");
+    }
+    if(contract->zones_available) {
+        furi_string_cat_printf(parsed_data, "Zones ");
+        for(int i = 0; i < 5; i++) {
+            if(contract->zones[i] != 0) {
+                furi_string_cat_printf(parsed_data, "%d", i + 1);
+                if(i < 4) {
+                    furi_string_cat_printf(parsed_data, ", ");
+                }
+            }
+        }
+        furi_string_cat_printf(parsed_data, "\n");
+    }
+    furi_string_cat_printf(parsed_data, "Vendu le : ");
+    locale_format_datetime_cat(parsed_data, &contract->sale_date, false);
     furi_string_cat_printf(parsed_data, "\n");
+    furi_string_cat_printf(
+        parsed_data,
+        "Agent de vente : %s (%d)\n",
+        get_service_provider(contract->sale_agent),
+        contract->sale_agent);
+    furi_string_cat_printf(parsed_data, "Terminal de vente : %d\n", contract->sale_device);
+    furi_string_cat_printf(parsed_data, "Etat : %d\n", contract->status);
+    furi_string_cat_printf(parsed_data, "Code authenticite : %d\n", contract->authenticator);
 }
 
 void show_environment_info(NavigoCardEnv* environment, FuriString* parsed_data) {
@@ -381,26 +460,32 @@ void show_environment_info(NavigoCardEnv* environment, FuriString* parsed_data)
 
 void update_page_info(NavigoContext* ctx, FuriString* parsed_data) {
     if(ctx->page_id == 0) {
-        furi_string_cat_printf(parsed_data, "\e#Navigo :\n");
-        furi_string_cat_printf(parsed_data, "\e#Contrat 1:\n");
-        show_contract_info(&ctx->card->contracts[0], parsed_data);
+        furi_string_cat_printf(
+            parsed_data, "\e#%s :\n", get_navigo_type(ctx->card->holder.card_status));
+        furi_string_cat_printf(parsed_data, "\e#Contrat 1 :\n");
+        show_contract_info(&ctx->card->contracts[0], ctx->card->ticket_count, parsed_data);
     } else if(ctx->page_id == 1) {
+        furi_string_cat_printf(
+            parsed_data, "\e#%s :\n", get_navigo_type(ctx->card->holder.card_status));
+        furi_string_cat_printf(parsed_data, "\e#Contrat 2 :\n");
+        show_contract_info(&ctx->card->contracts[1], ctx->card->ticket_count, parsed_data);
+    } else if(ctx->page_id == 2) {
         furi_string_cat_printf(parsed_data, "\e#Environnement :\n");
         show_environment_info(&ctx->card->environment, parsed_data);
-    } else if(ctx->page_id == 2) {
+    } else if(ctx->page_id == 3) {
         furi_string_cat_printf(parsed_data, "\e#Event 1 :\n");
         show_event_info(&ctx->card->events[0], parsed_data);
-    } else if(ctx->page_id == 3) {
+    } else if(ctx->page_id == 4) {
         furi_string_cat_printf(parsed_data, "\e#Event 2 :\n");
         show_event_info(&ctx->card->events[1], parsed_data);
-    } else if(ctx->page_id == 4) {
+    } else if(ctx->page_id == 5) {
         furi_string_cat_printf(parsed_data, "\e#Event 3 :\n");
         show_event_info(&ctx->card->events[2], parsed_data);
     }
 }
 
 void update_widget_elements(Widget* widget, NavigoContext* ctx, void* context) {
-    if(ctx->page_id < 4) {
+    if(ctx->page_id < 5) {
         widget_add_button_element(
             widget, GuiButtonTypeRight, "Next", metroflip_next_button_widget_callback, context);
     } else {
@@ -423,20 +508,24 @@ void metroflip_back_button_widget_callback(GuiButtonType result, InputType type,
     if(type == InputTypePress) {
         widget_reset(widget);
 
-        FuriString* parsed_data = furi_string_alloc();
-
         FURI_LOG_I(TAG, "Page ID: %d -> %d", ctx->page_id, ctx->page_id - 1);
 
         if(ctx->page_id > 0) {
+            if(ctx->page_id == 2 && ctx->card->contracts[1].tariff == 0) {
+                ctx->page_id -= 1;
+            }
             ctx->page_id -= 1;
         }
 
+        FuriString* parsed_data = furi_string_alloc();
+
         // Ensure no nested mutexes
         furi_mutex_acquire(ctx->mutex, FuriWaitForever);
         update_page_info(ctx, parsed_data);
         furi_mutex_release(ctx->mutex);
 
         widget_add_text_scroll_element(widget, 0, 0, 128, 64, furi_string_get_cstr(parsed_data));
+        // widget_add_icon_element(widget, 0, 0, &I_RFIDDolphinReceive_97x61);
 
         // Ensure no nested mutexes
         furi_mutex_acquire(ctx->mutex, FuriWaitForever);
@@ -457,11 +546,12 @@ void metroflip_next_button_widget_callback(GuiButtonType result, InputType type,
     if(type == InputTypePress) {
         widget_reset(widget);
 
-        FuriString* parsed_data = furi_string_alloc();
-
         FURI_LOG_I(TAG, "Page ID: %d -> %d", ctx->page_id, ctx->page_id + 1);
 
-        if(ctx->page_id < 4) {
+        if(ctx->page_id < 5) {
+            if(ctx->page_id == 0 && ctx->card->contracts[1].tariff == 0) {
+                ctx->page_id += 1;
+            }
             ctx->page_id += 1;
         } else {
             ctx->page_id = 0;
@@ -469,6 +559,8 @@ void metroflip_next_button_widget_callback(GuiButtonType result, InputType type,
                 app->scene_manager, MetroflipSceneStart);
         }
 
+        FuriString* parsed_data = furi_string_alloc();
+
         // Ensure no nested mutexes
         furi_mutex_acquire(ctx->mutex, FuriWaitForever);
         update_page_info(ctx, parsed_data);
@@ -485,6 +577,10 @@ void metroflip_next_button_widget_callback(GuiButtonType result, InputType type,
     }
 }
 
+void delay(int milliseconds) {
+    furi_thread_flags_wait(0, FuriFlagWaitAny, milliseconds);
+}
+
 static NfcCommand metroflip_scene_navigo_poller_callback(NfcGenericEvent event, void* context) {
     furi_assert(event.protocol == NfcProtocolIso14443_4b);
     NfcCommand next_command = NfcCommandContinue;
@@ -504,6 +600,11 @@ static NfcCommand metroflip_scene_navigo_poller_callback(NfcGenericEvent event,
 
     if(iso14443_4b_event->type == Iso14443_4bPollerEventTypeReady) {
         if(stage == MetroflipPollerEventTypeStart) {
+            // Start Flipper vibration
+            NotificationApp* notification = furi_record_open(RECORD_NOTIFICATION);
+            notification_message(notification, &sequence_set_vibro_on);
+            delay(50);
+            notification_message(notification, &sequence_reset_vibro);
             nfc_device_set_data(
                 app->nfc_device, NfcProtocolIso14443_4b, nfc_poller_get_data(app->poller));
 
@@ -514,10 +615,10 @@ static NfcCommand metroflip_scene_navigo_poller_callback(NfcGenericEvent event,
                 NavigoCardData* card = malloc(sizeof(NavigoCardData));
 
                 // Initialize the card
-                card->contracts = malloc(sizeof(NavigoCardContract));
+                card->contracts = malloc(2 * sizeof(NavigoCardContract));
                 card->events = malloc(3 * sizeof(NavigoCardEvent));
 
-                // Select app for contract 1
+                // Select app for contracts
                 error =
                     select_new_app(0x20, tx_buffer, rx_buffer, iso14443_4b_poller, app, &stage);
                 if(error != 0) {
@@ -529,33 +630,240 @@ static NfcCommand metroflip_scene_navigo_poller_callback(NfcGenericEvent event,
                     break;
                 }
 
-                // read file 1
-                error = read_new_file(1, tx_buffer, rx_buffer, iso14443_4b_poller, app, &stage);
-                if(error != 0) {
+                // Prepare calypso structure
+                CalypsoApp* NavigoContractStructure = get_navigo_contract_structure();
+                if(!NavigoContractStructure) {
+                    FURI_LOG_E(TAG, "Failed to load Navigo Contract structure");
                     break;
                 }
 
-                // Check the response after reading the file
-                if(check_response(rx_buffer, app, &stage, &response_length) != 0) {
-                    break;
-                }
+                // Now send the read command for contracts
+                for(size_t i = 1; i < 3; i++) {
+                    error =
+                        read_new_file(i, tx_buffer, rx_buffer, iso14443_4b_poller, app, &stage);
+                    if(error != 0) {
+                        break;
+                    }
 
-                char bit_representation[response_length * 8 + 1];
-                bit_representation[0] = '\0';
-                for(size_t i = 0; i < response_length; i++) {
-                    char bits[9];
-                    uint8_t byte = bit_buffer_get_byte(rx_buffer, i);
-                    byte_to_binary(byte, bits);
-                    strlcat(bit_representation, bits, sizeof(bit_representation));
+                    // Check the response after reading the file
+                    if(check_response(rx_buffer, app, &stage, &response_length) != 0) {
+                        break;
+                    }
+
+                    char bit_representation[response_length * 8 + 1];
+                    bit_representation[0] = '\0';
+                    for(size_t i = 0; i < response_length; i++) {
+                        char bits[9];
+                        uint8_t byte = bit_buffer_get_byte(rx_buffer, i);
+                        byte_to_binary(byte, bits);
+                        strlcat(bit_representation, bits, sizeof(bit_representation));
+                    }
+                    bit_representation[response_length * 8] = '\0';
+
+                    /* int count = 0;
+                    int start = 0, end = NavigoContractStructure->elements[0].bitmap->size;
+                    char bit_slice[end - start + 1];
+                    strncpy(bit_slice, bit_representation + start, end - start);
+                    bit_slice[end - start] = '\0';
+                    int* positions = get_bit_positions(bit_slice, &count);
+
+                    FURI_LOG_I(TAG, "Contract %d bit positions: %d", i, count);
+
+                    // print positions
+                    for(int i = 0; i < count; i++) {
+                        char* key =
+                            (NavigoContractStructure->elements[0]
+                                         .bitmap->elements[positions[i]]
+                                         .type == CALYPSO_ELEMENT_TYPE_FINAL ?
+                                 NavigoContractStructure->elements[0]
+                                     .bitmap->elements[positions[i]]
+                                     .final->key :
+                                 NavigoContractStructure->elements[0]
+                                     .bitmap->elements[positions[i]]
+                                     .bitmap->key);
+                        int offset = get_calypso_node_offset(
+                            bit_representation, key, NavigoContractStructure);
+                        FURI_LOG_I(
+                            TAG, "Position: %d, Key: %s, Offset: %d", positions[i], key, offset);
+                    } */
+
+                    // 2. ContractTariff
+                    const char* contract_key = "ContractTariff";
+                    if(is_calypso_node_present(
+                           bit_representation, contract_key, NavigoContractStructure)) {
+                        int positionOffset = get_calypso_node_offset(
+                            bit_representation, contract_key, NavigoContractStructure);
+                        int start = positionOffset,
+                            end = positionOffset +
+                                  get_calypso_node_size(contract_key, NavigoContractStructure) - 1;
+                        card->contracts[i - 1].tariff =
+                            bit_slice_to_dec(bit_representation, start, end);
+                    }
+
+                    // 3. ContractSerialNumber
+                    contract_key = "ContractSerialNumber";
+                    if(is_calypso_node_present(
+                           bit_representation, contract_key, NavigoContractStructure)) {
+                        int positionOffset = get_calypso_node_offset(
+                            bit_representation, contract_key, NavigoContractStructure);
+                        int start = positionOffset,
+                            end = positionOffset +
+                                  get_calypso_node_size(contract_key, NavigoContractStructure) - 1;
+                        card->contracts[i - 1].serial_number =
+                            bit_slice_to_dec(bit_representation, start, end);
+                        card->contracts[i - 1].serial_number_available = true;
+                    }
+
+                    // 8. ContractPayMethod
+                    contract_key = "ContractPayMethod";
+                    if(is_calypso_node_present(
+                           bit_representation, contract_key, NavigoContractStructure)) {
+                        int positionOffset = get_calypso_node_offset(
+                            bit_representation, contract_key, NavigoContractStructure);
+                        int start = positionOffset,
+                            end = positionOffset +
+                                  get_calypso_node_size(contract_key, NavigoContractStructure) - 1;
+                        card->contracts[i - 1].pay_method =
+                            bit_slice_to_dec(bit_representation, start, end);
+                        card->contracts[i - 1].pay_method_available = true;
+                    }
+
+                    // 10. ContractPriceAmount
+                    contract_key = "ContractPriceAmount";
+                    if(is_calypso_node_present(
+                           bit_representation, contract_key, NavigoContractStructure)) {
+                        int positionOffset = get_calypso_node_offset(
+                            bit_representation, contract_key, NavigoContractStructure);
+                        int start = positionOffset,
+                            end = positionOffset +
+                                  get_calypso_node_size(contract_key, NavigoContractStructure) - 1;
+                        card->contracts[i - 1].price_amount =
+                            bit_slice_to_dec(bit_representation, start, end) / 100.0;
+                        card->contracts[i - 1].price_amount_available = true;
+                    }
+
+                    // 13.0. ContractValidityStartDate
+                    contract_key = "ContractValidityStartDate";
+                    if(is_calypso_node_present(
+                           bit_representation, contract_key, NavigoContractStructure)) {
+                        int positionOffset = get_calypso_node_offset(
+                            bit_representation, contract_key, NavigoContractStructure);
+                        int start = positionOffset,
+                            end = positionOffset +
+                                  get_calypso_node_size(contract_key, NavigoContractStructure) - 1;
+                        float decimal_value =
+                            bit_slice_to_dec(bit_representation, start, end) * 24 * 3600;
+                        uint64_t start_validity_timestamp = (decimal_value + (float)epoch) + 3600;
+                        datetime_timestamp_to_datetime(
+                            start_validity_timestamp, &card->contracts[i - 1].start_date);
+                    }
+
+                    // 13.2. ContractValidityEndDate
+                    contract_key = "ContractValidityEndDate";
+                    if(is_calypso_node_present(
+                           bit_representation, contract_key, NavigoContractStructure)) {
+                        int positionOffset = get_calypso_node_offset(
+                            bit_representation, contract_key, NavigoContractStructure);
+                        int start = positionOffset,
+                            end = positionOffset +
+                                  get_calypso_node_size(contract_key, NavigoContractStructure) - 1;
+                        float decimal_value =
+                            bit_slice_to_dec(bit_representation, start, end) * 24 * 3600;
+                        uint64_t end_validity_timestamp = (decimal_value + (float)epoch) + 3600;
+                        datetime_timestamp_to_datetime(
+                            end_validity_timestamp, &card->contracts[i - 1].end_date);
+                        card->contracts[i - 1].end_date_available = true;
+                    }
+
+                    // 13.6. ContractValidityZones
+                    contract_key = "ContractValidityZones";
+                    if(is_calypso_node_present(
+                           bit_representation, contract_key, NavigoContractStructure)) {
+                        int start = get_calypso_node_offset(
+                            bit_representation, contract_key, NavigoContractStructure);
+                        // binary form is 00011111 for zones 5, 4, 3, 2, 1
+                        for(int j = 0; j < 5; j++) {
+                            card->contracts[i - 1].zones[j] =
+                                bit_slice_to_dec(bit_representation, start + 3 + j, start + 3 + j);
+                        }
+                        card->contracts[i - 1].zones_available = true;
+                    }
+
+                    // 13.7. ContractValidityJourneys  -- pas sûr de le mettre lui
+
+                    // 15.0. ContractValiditySaleDate
+                    contract_key = "ContractValiditySaleDate";
+                    if(is_calypso_node_present(
+                           bit_representation, contract_key, NavigoContractStructure)) {
+                        int positionOffset = get_calypso_node_offset(
+                            bit_representation, contract_key, NavigoContractStructure);
+                        int start = positionOffset,
+                            end = positionOffset +
+                                  get_calypso_node_size(contract_key, NavigoContractStructure) - 1;
+                        float decimal_value =
+                            bit_slice_to_dec(bit_representation, start, end) * 24 * 3600;
+                        uint64_t sale_timestamp = (decimal_value + (float)epoch) + 3600;
+                        datetime_timestamp_to_datetime(
+                            sale_timestamp, &card->contracts[i - 1].sale_date);
+                    }
+
+                    // 15.2. ContractValiditySaleAgent
+                    contract_key = "ContractValiditySaleAgent";
+                    if(is_calypso_node_present(
+                           bit_representation, contract_key, NavigoContractStructure)) {
+                        int positionOffset = get_calypso_node_offset(
+                            bit_representation, contract_key, NavigoContractStructure);
+                        int start = positionOffset,
+                            end = positionOffset +
+                                  get_calypso_node_size(contract_key, NavigoContractStructure) - 1;
+                        card->contracts[i - 1].sale_agent =
+                            bit_slice_to_dec(bit_representation, start, end);
+                    } else {
+                        card->contracts[i - 1].sale_agent = -1;
+                    }
+
+                    // 15.3. ContractValiditySaleDevice
+                    contract_key = "ContractValiditySaleDevice";
+                    if(is_calypso_node_present(
+                           bit_representation, contract_key, NavigoContractStructure)) {
+                        int positionOffset = get_calypso_node_offset(
+                            bit_representation, contract_key, NavigoContractStructure);
+                        int start = positionOffset,
+                            end = positionOffset +
+                                  get_calypso_node_size(contract_key, NavigoContractStructure) - 1;
+                        card->contracts[i - 1].sale_device =
+                            bit_slice_to_dec(bit_representation, start, end);
+                    }
+
+                    // 16. ContractStatus  -- 0x1 ou 0xff
+                    contract_key = "ContractStatus";
+                    if(is_calypso_node_present(
+                           bit_representation, contract_key, NavigoContractStructure)) {
+                        int positionOffset = get_calypso_node_offset(
+                            bit_representation, contract_key, NavigoContractStructure);
+                        int start = positionOffset,
+                            end = positionOffset +
+                                  get_calypso_node_size(contract_key, NavigoContractStructure) - 1;
+                        card->contracts[i - 1].status =
+                            bit_slice_to_dec(bit_representation, start, end);
+                    }
+
+                    // 18. ContractAuthenticator
+                    contract_key = "ContractAuthenticator";
+                    if(is_calypso_node_present(
+                           bit_representation, contract_key, NavigoContractStructure)) {
+                        int positionOffset = get_calypso_node_offset(
+                            bit_representation, contract_key, NavigoContractStructure);
+                        int start = positionOffset,
+                            end = positionOffset +
+                                  get_calypso_node_size(contract_key, NavigoContractStructure) - 1;
+                        card->contracts[i - 1].authenticator =
+                            bit_slice_to_dec(bit_representation, start, end);
+                    }
                 }
-                bit_representation[response_length * 8] = '\0';
-                int start = 55, end = 70;
-                float decimal_value = bit_slice_to_dec(bit_representation, start, end);
-                card->contracts[0].balance = decimal_value / 100;
-                start = 80, end = 93;
-                decimal_value = bit_slice_to_dec(bit_representation, start, end);
-                uint64_t start_date_timestamp = (decimal_value * 24 * 3600) + (float)epoch + 3600;
-                datetime_timestamp_to_datetime(start_date_timestamp, &card->contracts[0].start_dt);
+
+                // Free the calypso structure
+                free_calypso_structure(NavigoContractStructure);
 
                 // Select app for environment
                 error = select_new_app(0x1, tx_buffer, rx_buffer, iso14443_4b_poller, app, &stage);
@@ -590,15 +898,13 @@ static NfcCommand metroflip_scene_navigo_poller_callback(NfcGenericEvent event,
                         bits,
                         sizeof(environment_bit_representation));
                 }
-                start = 0;
-                end = 5;
+                FURI_LOG_I(
+                    TAG, "Environment bit_representation: %s", environment_bit_representation);
+                int start = 0;
+                int end = 5;
                 card->environment.app_version =
                     bit_slice_to_dec(environment_bit_representation, start, end);
                 start = 13;
-                end = 36;
-                decimal_value = bit_slice_to_dec(environment_bit_representation, start, end);
-                FURI_LOG_I(TAG, "Network ID: %d", (int)decimal_value);
-                start = 13;
                 end = 16;
                 card->environment.country_num =
                     bit_slice_to_dec(environment_bit_representation, start, end) * 100 +
@@ -612,11 +918,59 @@ static NfcCommand metroflip_scene_navigo_poller_callback(NfcGenericEvent event,
                     bit_slice_to_dec(environment_bit_representation, start + 8, end + 8);
                 start = 45;
                 end = 58;
-                decimal_value = bit_slice_to_dec(environment_bit_representation, start, end);
+                float decimal_value = bit_slice_to_dec(environment_bit_representation, start, end);
                 uint64_t end_validity_timestamp =
                     (decimal_value * 24 * 3600) + (float)epoch + 3600;
                 datetime_timestamp_to_datetime(end_validity_timestamp, &card->environment.end_dt);
 
+                start = 95;
+                end = 98;
+                card->holder.card_status =
+                    bit_slice_to_dec(environment_bit_representation, start, end);
+
+                start = 99;
+                end = 104;
+                card->holder.commercial_id =
+                    bit_slice_to_dec(environment_bit_representation, start, end);
+
+                // Select app for counters (remaining tickets on Navigo Easy)
+                error =
+                    select_new_app(0x2A, tx_buffer, rx_buffer, iso14443_4b_poller, app, &stage);
+                if(error != 0) {
+                    break;
+                }
+
+                // Check the response after selecting app
+                if(check_response(rx_buffer, app, &stage, &response_length) != 0) {
+                    break;
+                }
+
+                // read file 1
+                error = read_new_file(1, tx_buffer, rx_buffer, iso14443_4b_poller, app, &stage);
+                if(error != 0) {
+                    break;
+                }
+
+                // Check the response after reading the file
+                if(check_response(rx_buffer, app, &stage, &response_length) != 0) {
+                    break;
+                }
+
+                char counter_bit_representation[response_length * 8 + 1];
+                counter_bit_representation[0] = '\0';
+                for(size_t i = 0; i < response_length; i++) {
+                    char bits[9];
+                    uint8_t byte = bit_buffer_get_byte(rx_buffer, i);
+                    byte_to_binary(byte, bits);
+                    strlcat(counter_bit_representation, bits, sizeof(counter_bit_representation));
+                }
+                FURI_LOG_I(TAG, "Counter bit_representation: %s", counter_bit_representation);
+
+                // Ticket count
+                start = 2;
+                end = 5;
+                card->ticket_count = bit_slice_to_dec(counter_bit_representation, start, end);
+
                 // Select app for events
                 error =
                     select_new_app(0x10, tx_buffer, rx_buffer, iso14443_4b_poller, app, &stage);
@@ -629,8 +983,15 @@ static NfcCommand metroflip_scene_navigo_poller_callback(NfcGenericEvent event,
                     break;
                 }
 
+                // Load the calypso structure for events
+                CalypsoApp* NavigoEventStructure = get_navigo_event_structure();
+                if(!NavigoEventStructure) {
+                    FURI_LOG_E(TAG, "Failed to load Navigo Event structure");
+                    break;
+                }
+
                 // furi_string_cat_printf(parsed_data, "\e#Events :\n");
-                // Now send the read command
+                // Now send the read command for events
                 for(size_t i = 1; i < 4; i++) {
                     error =
                         read_new_file(i, tx_buffer, rx_buffer, iso14443_4b_poller, app, &stage);
@@ -651,183 +1012,168 @@ static NfcCommand metroflip_scene_navigo_poller_callback(NfcGenericEvent event,
                         byte_to_binary(byte, bits);
                         strlcat(event_bit_representation, bits, sizeof(event_bit_representation));
                     }
-                    FURI_LOG_I(
-                        TAG, "Event %d bit_representation: %s", i, event_bit_representation);
 
                     // furi_string_cat_printf(parsed_data, "Event 0%d :\n", i);
-                    int count = 0;
-                    int start = 25, end = 53;
+                    /* int count = 0;
+                    int start = 25, end = 52;
                     char bit_slice[end - start + 2];
                     strncpy(bit_slice, event_bit_representation + start, end - start + 1);
                     bit_slice[end - start + 1] = '\0';
                     int* positions = get_bit_positions(bit_slice, &count);
-                    /*FURI_LOG_I(TAG, "Positions: ");
+                    FURI_LOG_I(TAG, "Positions: ");
                     for(int i = 0; i < count; i++) {
                         FURI_LOG_I(TAG, "%d ", positions[i]);
-                    }*/
+                    } */
 
                     // 2. EventCode
-                    // 8 bits
-                    int event_number = 2;
-                    if(is_event_present(positions, count, event_number)) {
-                        int positionOffset = check_events(positions, count, event_number);
-                        int start = positionOffset, end = positionOffset + 7;
+                    const char* event_key = "EventCode";
+                    if(is_calypso_node_present(
+                           event_bit_representation, event_key, NavigoEventStructure)) {
+                        int positionOffset = get_calypso_node_offset(
+                            event_bit_representation, event_key, NavigoEventStructure);
+                        int start = positionOffset,
+                            end = positionOffset +
+                                  get_calypso_node_size(event_key, NavigoEventStructure) - 1;
                         int decimal_value = bit_slice_to_dec(event_bit_representation, start, end);
                         card->events[i - 1].transport_type = decimal_value >> 4;
                         card->events[i - 1].transition = decimal_value & 15;
-                        FURI_LOG_I(
-                            TAG,
-                            "%s - %s",
-                            TRANSPORT_LIST[card->events[i - 1].transport_type],
-                            TRANSITION_LIST[card->events[i - 1].transition]);
                     }
 
                     // 4. EventServiceProvider
-                    // 8 bits
-                    event_number = 4;
-                    if(is_event_present(positions, count, event_number)) {
-                        int positionOffset = check_events(positions, count, event_number);
-                        start = positionOffset, end = positionOffset + 7;
+                    event_key = "EventServiceProvider";
+                    if(is_calypso_node_present(
+                           event_bit_representation, event_key, NavigoEventStructure)) {
+                        int positionOffset = get_calypso_node_offset(
+                            event_bit_representation, event_key, NavigoEventStructure);
+                        start = positionOffset,
+                        end = positionOffset +
+                              get_calypso_node_size(event_key, NavigoEventStructure) - 1;
                         card->events[i - 1].service_provider =
                             bit_slice_to_dec(event_bit_representation, start, end);
-                        FURI_LOG_I(
-                            TAG,
-                            "Transporteur : %s",
-                            SERVICE_PROVIDERS[card->events[i - 1].service_provider]);
                     }
 
                     // 8. EventLocationId
-                    // 16 bits
-                    event_number = 8;
-                    if(is_event_present(positions, count, event_number)) {
-                        int positionOffset = check_events(positions, count, event_number);
-                        start = positionOffset, end = positionOffset + 15;
+                    event_key = "EventLocationId";
+                    if(is_calypso_node_present(
+                           event_bit_representation, event_key, NavigoEventStructure)) {
+                        int positionOffset = get_calypso_node_offset(
+                            event_bit_representation, event_key, NavigoEventStructure);
+                        start = positionOffset,
+                        end = positionOffset +
+                              get_calypso_node_size(event_key, NavigoEventStructure) - 1;
                         int decimal_value = bit_slice_to_dec(event_bit_representation, start, end);
                         card->events[i - 1].station_group_id = decimal_value >> 9;
                         card->events[i - 1].station_id = (decimal_value >> 4) & 31;
-                        if(card->events[i - 1].transport_type == METRO) {
-                            FURI_LOG_I(
-                                TAG,
-                                "Secteur %s - Station %s",
-                                METRO_STATION_LIST[card->events[i - 1].station_group_id][0],
-                                METRO_STATION_LIST[card->events[i - 1].station_group_id]
-                                                  [card->events[i - 1].station_id]);
-                        } else if(card->events[i - 1].transport_type == TRAIN) {
-                            FURI_LOG_I(
-                                TAG,
-                                "Ligne %s - Station %s",
-                                TRAIN_LINES_LIST[card->events[i - 1].station_group_id],
-                                TRAIN_STATION_LIST[card->events[i - 1].station_group_id]
-                                                  [card->events[i - 1].station_id]);
-                        } else {
-                            FURI_LOG_I(
-                                TAG,
-                                "Groupe ID %d - Station ID %d",
-                                card->events[i - 1].station_group_id,
-                                card->events[i - 1].station_id);
-                        }
                     }
 
                     // 9. EventLocationGate
-                    // 8 bits
-                    event_number = 9;
-                    if(is_event_present(positions, count, event_number)) {
-                        int positionOffset = check_events(positions, count, event_number);
-                        start = positionOffset, end = positionOffset + 7;
+                    event_key = "EventLocationGate";
+                    if(is_calypso_node_present(
+                           event_bit_representation, event_key, NavigoEventStructure)) {
+                        int positionOffset = get_calypso_node_offset(
+                            event_bit_representation, event_key, NavigoEventStructure);
+                        start = positionOffset,
+                        end = positionOffset +
+                              get_calypso_node_size(event_key, NavigoEventStructure) - 1;
                         card->events[i - 1].location_gate =
                             bit_slice_to_dec(event_bit_representation, start, end);
                         card->events[i - 1].location_gate_available = true;
-                        FURI_LOG_I(TAG, "Passage : %d", card->events[i - 1].location_gate);
                     }
 
                     // 10. EventDevice
-                    // 16 bits
-                    event_number = 10;
-                    if(is_event_present(positions, count, event_number)) {
-                        int positionOffset = check_events(positions, count, event_number);
-                        start = positionOffset, end = positionOffset + 15;
+                    event_key = "EventDevice";
+                    if(is_calypso_node_present(
+                           event_bit_representation, event_key, NavigoEventStructure)) {
+                        int positionOffset = get_calypso_node_offset(
+                            event_bit_representation, event_key, NavigoEventStructure);
+                        start = positionOffset,
+                        end = positionOffset +
+                              get_calypso_node_size(event_key, NavigoEventStructure) - 1;
                         int decimal_value = bit_slice_to_dec(event_bit_representation, start, end);
                         card->events[i - 1].device = decimal_value >> 8;
                         card->events[i - 1].door = card->events[i - 1].device / 2 + 1;
                         card->events[i - 1].side = card->events[i - 1].device % 2;
                         card->events[i - 1].device_available = true;
-                        const char* side = card->events[i - 1].side == 0 ? "droit" : "gauche";
-                        FURI_LOG_I(TAG, "Equipement : %d", card->events[i - 1].device);
-                        FURI_LOG_I(TAG, "Porte : %d - Côté %s", card->events[i - 1].door, side);
                     }
 
                     // 11. EventRouteNumber
-                    // 16 bits
-                    event_number = 11;
-                    if(is_event_present(positions, count, event_number)) {
-                        int positionOffset = check_events(positions, count, event_number);
-                        start = positionOffset, end = positionOffset + 15;
+                    event_key = "EventRouteNumber";
+                    if(is_calypso_node_present(
+                           event_bit_representation, event_key, NavigoEventStructure)) {
+                        int positionOffset = get_calypso_node_offset(
+                            event_bit_representation, event_key, NavigoEventStructure);
+                        start = positionOffset,
+                        end = positionOffset +
+                              get_calypso_node_size(event_key, NavigoEventStructure) - 1;
                         card->events[i - 1].route_number =
                             bit_slice_to_dec(event_bit_representation, start, end);
                         card->events[i - 1].route_number_available = true;
-                        FURI_LOG_I(TAG, "Route : %d", card->events[i - 1].route_number);
                     }
 
                     // 13. EventJourneyRun
-                    // 16 bits
-                    event_number = 13;
-                    if(is_event_present(positions, count, event_number)) {
-                        int positionOffset = check_events(positions, count, event_number);
-                        start = positionOffset, end = positionOffset + 15;
+                    event_key = "EventJourneyRun";
+                    if(is_calypso_node_present(
+                           event_bit_representation, event_key, NavigoEventStructure)) {
+                        int positionOffset = get_calypso_node_offset(
+                            event_bit_representation, event_key, NavigoEventStructure);
+                        start = positionOffset,
+                        end = positionOffset +
+                              get_calypso_node_size(event_key, NavigoEventStructure) - 1;
                         card->events[i - 1].mission =
                             bit_slice_to_dec(event_bit_representation, start, end);
                         card->events[i - 1].mission_available = true;
-                        FURI_LOG_I(TAG, "Mission : %d", card->events[i - 1].mission);
                     }
 
                     // 14. EventVehicleId
-                    // 16 bits
-                    event_number = 14;
-                    if(is_event_present(positions, count, event_number)) {
-                        int positionOffset = check_events(positions, count, event_number);
-                        start = positionOffset, end = positionOffset + 15;
+                    event_key = "EventVehicleId";
+                    if(is_calypso_node_present(
+                           event_bit_representation, event_key, NavigoEventStructure)) {
+                        int positionOffset = get_calypso_node_offset(
+                            event_bit_representation, event_key, NavigoEventStructure);
+                        start = positionOffset,
+                        end = positionOffset +
+                              get_calypso_node_size(event_key, NavigoEventStructure) - 1;
                         card->events[i - 1].vehicle_id =
                             bit_slice_to_dec(event_bit_representation, start, end);
                         card->events[i - 1].vehicle_id_available = true;
-                        FURI_LOG_I(TAG, "Vehicule : %d", card->events[i - 1].vehicle_id);
                     }
 
                     // 25. EventContractPointer
-                    // 5 bits
-                    event_number = 25;
-                    if(is_event_present(positions, count, event_number)) {
-                        int positionOffset = check_events(positions, count, event_number);
-                        start = positionOffset, end = positionOffset + 4;
+                    event_key = "EventContractPointer";
+                    if(is_calypso_node_present(
+                           event_bit_representation, event_key, NavigoEventStructure)) {
+                        int positionOffset = get_calypso_node_offset(
+                            event_bit_representation, event_key, NavigoEventStructure);
+                        start = positionOffset,
+                        end = positionOffset +
+                              get_calypso_node_size(event_key, NavigoEventStructure) - 1;
                         card->events[i - 1].used_contract =
                             bit_slice_to_dec(event_bit_representation, start, end);
                         card->events[i - 1].used_contract_available = true;
-                        FURI_LOG_I(TAG, "Contrat : %d", card->events[i - 1].used_contract);
                     }
 
-                    free(positions);
-
-                    // EventDate
-                    // 14 bits
-                    start = 0, end = 13;
+                    // EventDateStamp
+                    event_key = "EventDateStamp";
+                    int positionOffset = get_calypso_node_offset(
+                        event_bit_representation, event_key, NavigoEventStructure);
+                    start = positionOffset,
+                    end = positionOffset + get_calypso_node_size(event_key, NavigoEventStructure) -
+                          1;
                     int decimal_value = bit_slice_to_dec(event_bit_representation, start, end);
                     uint64_t date_timestamp = (decimal_value * 24 * 3600) + epoch + 3600;
                     datetime_timestamp_to_datetime(date_timestamp, &card->events[i - 1].date);
 
-                    // EventTime
-                    // 11 bits
-                    start = 14, end = 24;
+                    // EventTimeStamp
+                    event_key = "EventTimeStamp";
+                    positionOffset = get_calypso_node_offset(
+                        event_bit_representation, event_key, NavigoEventStructure);
+                    start = positionOffset,
+                    end = positionOffset + get_calypso_node_size(event_key, NavigoEventStructure) -
+                          1;
                     decimal_value = bit_slice_to_dec(event_bit_representation, start, end);
                     card->events[i - 1].date.hour = (decimal_value * 60) / 3600;
                     card->events[i - 1].date.minute = ((decimal_value * 60) % 3600) / 60;
                     card->events[i - 1].date.second = ((decimal_value * 60) % 3600) % 60;
-                    FURI_LOG_I(
-                        TAG,
-                        "Date : %02d/%02d/%04d %02dh%02d",
-                        card->events[i - 1].date.day,
-                        card->events[i - 1].date.month,
-                        card->events[i - 1].date.year,
-                        card->events[i - 1].date.hour,
-                        card->events[i - 1].date.minute);
                 }
                 UNUSED(TRANSITION_LIST);
                 UNUSED(TRANSPORT_LIST);

scenes/navigo.h

@@ -1,6 +1,8 @@
 #include "../metroflip_i.h"
-#include <stdbool.h>
+#include "../api/calypso/calypso_util.h"
+#include "../api/calypso/cards/navigo.h"
 #include <datetime.h>
+#include <stdbool.h>
 
 #ifndef METRO_LIST_H
 #define METRO_LIST_H
@@ -42,14 +44,36 @@ typedef struct {
 } NavigoCardEnv;
 
 typedef struct {
-    float balance;
-    DateTime start_dt;
+    int card_status;
+    int commercial_id;
+} NavigoCardHolder;
+
+typedef struct {
+    int tariff;
+    int serial_number;
+    bool serial_number_available;
+    int pay_method;
+    bool pay_method_available;
+    double price_amount;
+    bool price_amount_available;
+    DateTime start_date;
+    DateTime end_date;
+    bool end_date_available;
+    int zones[5];
+    bool zones_available;
+    DateTime sale_date;
+    int sale_agent;
+    int sale_device;
+    int status;
+    int authenticator;
 } NavigoCardContract;
 
 typedef struct {
     NavigoCardEnv environment;
+    NavigoCardHolder holder;
     NavigoCardContract* contracts;
     NavigoCardEvent* events;
+    int ticket_count;
 } NavigoCardData;
 
 typedef struct {
@@ -60,13 +84,6 @@ typedef struct {
     FuriMutex* mutex;
 } NavigoContext;
 
-/* // Navigo Card Subscriptions Types
-static const char* SUBSCRIPTIONS_LIST[] = {
-    [1] = "Navigo decouverte",
-    [2] = "Navigo standard",
-    [6] = " Navigo integral",
-    [14] = "Imagine R (etudiant)"}; */
-
 // Service Providers
 static const char* SERVICE_PROVIDERS[] = {
     [2] = "SNCF",
@@ -94,6 +111,14 @@ typedef enum {
     PARKING = 8
 } TRANSPORT_TYPE;
 
+typedef enum {
+    NAVIGO_EASY = 0,
+    NAVIGO_DECOUVERTE = 1,
+    NAVIGO_STANDARD = 2,
+    NAVIGO_INTEGRAL = 6,
+    IMAGINE_R = 14
+} CARD_STATUS;
+
 // Transition Types
 static const char* TRANSITION_LIST[] = {
     [1] = "Validation en entree",