Update Opus card (Montreal) event structure

api/calypso/cards/opus.c

@@ -8,7 +8,7 @@ CalypsoApp* get_opus_contract_structure() {
         return NULL;
     }
 
-    int app_elements_count = 2;
+    int app_elements_count = 1;
 
     OpusContractStructure->type = CALYPSO_APP_CONTRACT;
     OpusContractStructure->container = malloc(sizeof(CalypsoContainerElement));
@@ -16,41 +16,85 @@ CalypsoApp* get_opus_contract_structure() {
         malloc(app_elements_count * sizeof(CalypsoElement));
     OpusContractStructure->container->size = app_elements_count;
 
-    OpusContractStructure->container->elements[0] =
-        make_calypso_final_element("ContractUnknownA", 3, "Unknown A", CALYPSO_FINAL_TYPE_NUMBER);
-    OpusContractStructure->container->elements[1] = make_calypso_bitmap_element(
+    OpusContractStructure->container->elements[0] = make_calypso_bitmap_element(
         "Contract",
-        4,
+        7,
         (CalypsoElement[]){
             make_calypso_final_element(
-                "ContractProvider", 8, "Provider", CALYPSO_FINAL_TYPE_UNKNOWN),
-            make_calypso_final_element("ContractTariff", 16, "Tariff", CALYPSO_FINAL_TYPE_TARIFF),
+                "ContractProvider",
+                8,
+                "Acteur ou groupe d’acteurs ayant dèfini et assurant le service pour le contrat",
+                CALYPSO_FINAL_TYPE_SERVICE_PROVIDER),
+            make_calypso_final_element(
+                "ContractTariff", 16, "Code tarif du contrat", CALYPSO_FINAL_TYPE_TARIFF),
             make_calypso_bitmap_element(
-                "ContractDates",
+                "ContractValidityInfoBitmap",
                 2,
                 (CalypsoElement[]){
                     make_calypso_final_element(
-                        "ContractStartDate", 14, "Start date", CALYPSO_FINAL_TYPE_DATE),
+                        "ContractValidityStartDate",
+                        14,
+                        "Date de début de validité du contrat",
+                        CALYPSO_FINAL_TYPE_DATE),
                     make_calypso_final_element(
-                        "ContractEndDate", 14, "End date", CALYPSO_FINAL_TYPE_DATE),
+                        "ContractValidityEndDate",
+                        14,
+                        "Date de fin de validité du contrat",
+                        CALYPSO_FINAL_TYPE_DATE),
                 }),
             make_calypso_bitmap_element(
-                "ContractSaleData",
-                6,
+                "ContractData",
+                9,
                 (CalypsoElement[]){
                     make_calypso_final_element(
-                        "ContractUnknownB", 17, "Unknown B", CALYPSO_FINAL_TYPE_NUMBER),
+                        "ContractDataSaleAgent",
+                        8,
+                        "Acteur ayant effectué la dernière vente sur le contrat",
+                        CALYPSO_FINAL_TYPE_SERVICE_PROVIDER),
                     make_calypso_final_element(
-                        "ContractSaleDate", 14, "Sale date", CALYPSO_FINAL_TYPE_DATE),
+                        "ContractDataSaleSecureDevice",
+                        32,
+                        "Numéro du SAM utilisé pour charger le contrat",
+                        CALYPSO_FINAL_TYPE_UNKNOWN),
                     make_calypso_final_element(
-                        "ContractSaleTime", 11, "Sale time", CALYPSO_FINAL_TYPE_TIME),
+                        "ContractDataSaleDate",
+                        14,
+                        "Date de chargement initial du contrat",
+                        CALYPSO_FINAL_TYPE_DATE),
                     make_calypso_final_element(
-                        "ContractUnknownC", 36, "Unknown C", CALYPSO_FINAL_TYPE_NUMBER),
+                        "ContractDataSaleTime",
+                        11,
+                        "Heure de chargement initial du contrat",
+                        CALYPSO_FINAL_TYPE_TIME),
                     make_calypso_final_element(
-                        "ContractStatus", 8, "Status", CALYPSO_FINAL_TYPE_UNKNOWN),
+                        "ContractDataReloadDate",
+                        14,
+                        "Date de rechargement du contrat",
+                        CALYPSO_FINAL_TYPE_DATE),
+                    make_calypso_final_element(
+                        "ContractDataValidityLimitDate",
+                        14,
+                        "Date limite pour une première utilisation du contrat",
+                        CALYPSO_FINAL_TYPE_DATE),
+                    make_calypso_final_element(
+                        "ContractDataEndInhibitionDate",
+                        14,
+                        "Date jusqu’à laquelle la prèsence du contrat dans une liste de suspension est ignorée",
+                        CALYPSO_FINAL_TYPE_DATE),
                     make_calypso_final_element(
-                        "ContractUnknownD", 36, "Unknown D", CALYPSO_FINAL_TYPE_NUMBER),
+                        "ContractDataInhibition", 1, "Contrat invalide", CALYPSO_FINAL_TYPE_UNKNOWN),
+                    make_calypso_final_element(
+                        "ContractDataUsed",
+                        1,
+                        "Contrat déjà validé au moins une fois",
+                        CALYPSO_FINAL_TYPE_UNKNOWN),
                 }),
+            make_calypso_final_element(
+                "ContractUnknownE", 0, "Unknown E", CALYPSO_FINAL_TYPE_UNKNOWN),
+            make_calypso_final_element(
+                "ContractUnknownF", 0, "Unknown F", CALYPSO_FINAL_TYPE_UNKNOWN),
+            make_calypso_final_element(
+                "ContractUnknownG", 0, "Unknown G", CALYPSO_FINAL_TYPE_UNKNOWN),
         });
 
     return OpusContractStructure;

api/calypso/transit/opus.c

@@ -17,6 +17,8 @@ const char* get_opus_service_provider(int provider) {
         return "STL";
     case 0x10:
         return "STLevis";
+    case 0x20:
+        return "Chrono";
     default: {
         char* provider_str = malloc(10 * sizeof(char));
         if(!provider_str) {
@@ -117,10 +119,14 @@ void show_opus_contract_info(OpusCardContract* contract, FuriString* parsed_data
     locale_format_datetime_cat(parsed_data, &contract->start_date, false);
     furi_string_cat_printf(parsed_data, "\nto: ");
     locale_format_datetime_cat(parsed_data, &contract->end_date, false);
-    furi_string_cat_printf(parsed_data, "\n");
-    // furi_string_cat_printf(parsed_data, "Sold on: ");
-    // locale_format_datetime_cat(parsed_data, &contract->sale_date, false);
-    // furi_string_cat_printf(parsed_data, "\nStatus: %d\n", contract->status);
+    furi_string_cat_printf(parsed_data, "\nSold on: ");
+    locale_format_datetime_cat(parsed_data, &contract->sale_date, true);
+    furi_string_cat_printf(
+        parsed_data, "\nSales Agent: %s\n", get_opus_service_provider(contract->sale_agent));
+    if(contract->inhibition) {
+        furi_string_cat_printf(parsed_data, "Contract inhibited\n");
+    }
+    furi_string_cat_printf(parsed_data, "Used: %s\n", contract->used ? "true" : "false");
 }
 
 void show_opus_environment_info(

api/calypso/transit/opus_i.h

@@ -42,8 +42,10 @@ typedef struct {
     int tariff;
     DateTime start_date;
     DateTime end_date;
+    int sale_agent;
     DateTime sale_date;
-    int status;
+    bool inhibition;
+    bool used;
     bool present;
 } OpusCardContract;
 

scenes/metroflip_scene_calypso.c

@@ -1349,11 +1349,6 @@ static NfcCommand metroflip_scene_calypso_poller_callback(NfcGenericEvent event,
                     env_key = "HolderBirthDate";
                     positionOffset = get_calypso_node_offset(
                         environment_bit_representation, env_key, OpusEnvHolderStructure);
-                    FURI_LOG_I(TAG, "HolderBirthDate positionOffset: %d", positionOffset);
-                    FURI_LOG_I(
-                        TAG,
-                        "HolderBirthDate size: %d",
-                        get_calypso_node_size(env_key, OpusEnvHolderStructure));
                     start = positionOffset, end = positionOffset + 3;
                     card->opus->holder.birth_date.year =
                         bit_slice_to_dec(environment_bit_representation, start, end) * 1000 +
@@ -1424,7 +1419,7 @@ static NfcCommand metroflip_scene_calypso_poller_callback(NfcGenericEvent event,
                         if(bit_slice_to_dec(
                                bit_representation,
                                0,
-                               OpusContractStructure->container->elements[1].bitmap->size - 1) ==
+                               OpusContractStructure->container->elements[0].bitmap->size - 1) ==
                            0) {
                             break;
                         }
@@ -1460,8 +1455,8 @@ static NfcCommand metroflip_scene_calypso_poller_callback(NfcGenericEvent event,
                                 bit_slice_to_dec(bit_representation, start, end);
                         }
 
-                        // ContractStartDate
-                        contract_key = "ContractStartDate";
+                        // ContractValidityStartDate
+                        contract_key = "ContractValidityStartDate";
                         if(is_calypso_node_present(
                                bit_representation, contract_key, OpusContractStructure)) {
                             int positionOffset = get_calypso_node_offset(
@@ -1479,8 +1474,8 @@ static NfcCommand metroflip_scene_calypso_poller_callback(NfcGenericEvent event,
                                 &card->opus->contracts[i - 1].start_date);
                         }
 
-                        // ContractEndDate
-                        contract_key = "ContractEndDate";
+                        // ContractValidityEndDate
+                        contract_key = "ContractValidityEndDate";
                         if(is_calypso_node_present(
                                bit_representation, contract_key, OpusContractStructure)) {
                             int positionOffset = get_calypso_node_offset(
@@ -1497,8 +1492,8 @@ static NfcCommand metroflip_scene_calypso_poller_callback(NfcGenericEvent event,
                                 end_validity_timestamp, &card->opus->contracts[i - 1].end_date);
                         }
 
-                        // ContractStatus
-                        contract_key = "ContractStatus";
+                        // ContractDataSaleAgent
+                        contract_key = "ContractDataSaleAgent";
                         if(is_calypso_node_present(
                                bit_representation, contract_key, OpusContractStructure)) {
                             int positionOffset = get_calypso_node_offset(
@@ -1507,24 +1502,31 @@ static NfcCommand metroflip_scene_calypso_poller_callback(NfcGenericEvent event,
                                 end = positionOffset +
                                       get_calypso_node_size(contract_key, OpusContractStructure) -
                                       1;
-                            card->opus->contracts[i - 1].status =
+                            card->opus->contracts[i - 1].sale_agent =
                                 bit_slice_to_dec(bit_representation, start, end);
                         }
 
-                        // ContractSaleDate + ContractSaleTime
-                        contract_key = "ContractSaleDate";
+                        // ContractDataSaleDate + ContractDataSaleTime
+                        contract_key = "ContractDataSaleDate";
                         int positionOffset = get_calypso_node_offset(
                             bit_representation, contract_key, OpusContractStructure);
+                        FURI_LOG_I(TAG, "ContractDataSaleDate positionOffset: %d", positionOffset);
                         int start = positionOffset,
                             end = positionOffset +
                                   get_calypso_node_size(contract_key, OpusContractStructure) - 1;
+                        FURI_LOG_I(
+                            TAG,
+                            "ContractDataSaleDate: %d",
+                            bit_slice_to_dec(bit_representation, start, end));
                         uint64_t sale_date_timestamp =
-                            (bit_slice_to_dec(bit_representation, start, end) + (float)epoch) +
+                            ((bit_slice_to_dec(bit_representation, start, end) * 24 * 3600) +
+                             (float)epoch) +
                             3600;
+                        ;
                         datetime_timestamp_to_datetime(
                             sale_date_timestamp, &card->opus->contracts[i - 1].sale_date);
 
-                        contract_key = "ContractSaleTime";
+                        contract_key = "ContractDataSaleTime";
                         positionOffset = get_calypso_node_offset(
                             bit_representation, contract_key, OpusContractStructure);
                         start = positionOffset,
@@ -1536,6 +1538,34 @@ static NfcCommand metroflip_scene_calypso_poller_callback(NfcGenericEvent event,
                             ((decimal_value * 60) % 3600) / 60;
                         card->opus->contracts[i - 1].sale_date.second =
                             ((decimal_value * 60) % 3600) % 60;
+
+                        // ContractDataInhibition
+                        contract_key = "ContractDataInhibition";
+                        if(is_calypso_node_present(
+                               bit_representation, contract_key, OpusContractStructure)) {
+                            int positionOffset = get_calypso_node_offset(
+                                bit_representation, contract_key, OpusContractStructure);
+                            int start = positionOffset,
+                                end = positionOffset +
+                                      get_calypso_node_size(contract_key, OpusContractStructure) -
+                                      1;
+                            card->opus->contracts[i - 1].inhibition =
+                                bit_slice_to_dec(bit_representation, start, end);
+                        }
+
+                        // ContractDataUsed
+                        contract_key = "ContractDataUsed";
+                        if(is_calypso_node_present(
+                               bit_representation, contract_key, OpusContractStructure)) {
+                            int positionOffset = get_calypso_node_offset(
+                                bit_representation, contract_key, OpusContractStructure);
+                            int start = positionOffset,
+                                end = positionOffset +
+                                      get_calypso_node_size(contract_key, OpusContractStructure) -
+                                      1;
+                            card->opus->contracts[i - 1].used =
+                                bit_slice_to_dec(bit_representation, start, end);
+                        }
                     }
 
                     // Free the calypso structure