Update src/streamlit_app.py

src/streamlit_app.py

@@ -7,6 +7,7 @@ import os
 import pytz
 
 # --- Inizializzazione Session State ---
+# Queste variabili mantengono lo stato dell'applicazione tra i refresh
 if 'file_uploader_key_json' not in st.session_state:
     st.session_state.file_uploader_key_json = 'json_uploader_0'
 if 'file_uploader_key_customers' not in st.session_state:
@@ -17,6 +18,7 @@ if 'customers_df' not in st.session_state:
     st.session_state.customers_df = pd.DataFrame()
 
 # --- CSS personalizzato ---
+# Stili per rendere l'interfaccia più gradevole
 st.markdown(
     """
     <style>
@@ -52,6 +54,20 @@ UTC_TIMEZONE = pytz.utc
 
 # Funzione di conversione per Outbound
 def convert_json_to_excel_data_outbound(json_file_content: str, customers_df_input: pd.DataFrame = None):
+    """
+    Converte il contenuto di un file JSON di tipo 'Ordine Outbound' in un DataFrame Pandas,
+    arricchendo i dati con informazioni da un DataFrame di clienti fornito.
+
+    Args:
+        json_file_content (str): Il contenuto del file JSON come stringa.
+        customers_df_input (pd.DataFrame, optional): DataFrame contenente l'anagrafica dei clienti.
+                                                      Deve includere 'code', 'company.code' e altri campi partner.
+                                                      Defaults to None.
+
+    Returns:
+        pd.DataFrame: Un DataFrame Pandas con i dati estratti e formattati,
+                      o None se si verifica un errore bloccante.
+    """
     try:
         json_data = json.loads(json_file_content)
 
@@ -64,23 +80,23 @@ def convert_json_to_excel_data_outbound(json_file_content: str, customers_df_inp
         
         order_number = outbound_info.get('orderNumber')
         order_type_json = outbound_info.get('orderType')
-        delivery_type_fixed = "DELIVERY" 
+        delivery_type_fixed = "DELIVERY" # Valore fisso
 
-        order_doc_date_str = outbound_info.get('orderDocDate') 
-        date_detail_json = outbound_info.get('orderDateDetail') 
-        due_date_str = outbound_info.get('orderDate') 
+        order_doc_date_str = outbound_info.get('orderDocDate')
+        date_detail_json = outbound_info.get('orderDateDetail')
+        due_date_str = outbound_info.get('orderDate')
 
         reason_code = outbound_info.get('reasonCode')
         payment_info_value = outbound_info.get('paymentInfo', {}).get('value')
         
         delivery_customer = outbound_info.get('deliveryCustomer', {})
         customer_code = delivery_customer.get('code')
-        customer_mail = delivery_customer.get('refMail') 
+        customer_mail = delivery_customer.get('refMail')
 
-        # Consignee data (from JSON)
+        # Consignee data (from JSON - destinatario della merce)
         consignee_name = delivery_customer.get('name')
         consignee_address_base = delivery_customer.get('address', '')
-        consignee_address_number = delivery_customer.get('addressNumber', '') 
+        consignee_address_number = delivery_customer.get('addressNumber', '')
         
         consignee_address = f"{consignee_address_base} {consignee_address_number}".strip() if consignee_address_base or consignee_address_number else ""
 
@@ -89,21 +105,21 @@ def convert_json_to_excel_data_outbound(json_file_content: str, customers_df_inp
         consignee_zip_code = delivery_customer.get('zipCode')
         consignee_country = delivery_customer.get('country')
 
-        # Customer data (from Excel lookup)
+        # Customer data (from Excel lookup - cliente effettivo che ha fatto l'ordine)
         customer_name = ""
-        customer_address = "" 
+        customer_address = ""
         customer_city = ""
         customer_province = ""
         customer_zip_code = ""
         customer_country = ""
         
-        # Esegui la lookup solo se customers_df_input è fornito e non vuoto
+        # Esegue la lookup solo se customers_df_input è fornito e non vuoto
         if customers_df_input is not None and not customers_df_input.empty and customer_code and company_code_json:
             
             # Filtra per 'code' e 'company.code' (assicurandosi che siano stringhe)
             # Aggiunto controllo per tipo stringa prima del confronto
             customer_data = customers_df_input[
-                (customers_df_input['code'].astype(str) == str(customer_code)) & 
+                (customers_df_input['code'].astype(str) == str(customer_code)) &
                 (customers_df_input['company.code'].astype(str) == str(company_code_json))
             ]
 
@@ -132,8 +148,8 @@ def convert_json_to_excel_data_outbound(json_file_content: str, customers_df_inp
             return None # Errore bloccante se l'Excel clienti non è disponibile
 
         # Note fields
-        note_ddt = outbound_info.get('noteDdt') 
-        note_warehouse = outbound_info.get('noteWarehouse') 
+        note_ddt = outbound_info.get('noteDdt')
+        note_warehouse = outbound_info.get('noteWarehouse')
         
         note_delivery = outbound_info.get('noteDelivery')
         note_shipment = outbound_info.get('noteShipment')
@@ -142,69 +158,65 @@ def convert_json_to_excel_data_outbound(json_file_content: str, customers_df_inp
         booking_info = outbound_info.get('bookingInfo')
 
         # Formattazione delle date
-        order_date_formatted = None 
+        order_date_formatted = None
         if order_doc_date_str:
             try:
+                # Rimuovi 'Z' per compatibilità con fromisoformat se presente
                 dt_object = datetime.fromisoformat(order_doc_date_str.replace('Z', ''))
                 order_date_formatted = dt_object.strftime('%d/%m/%Y')
             except ValueError:
-                order_date_formatted = order_doc_date_str
+                order_date_formatted = order_doc_date_str # Usa la stringa originale se il parsing fallisce
                 st.warning(f"Attenzione: Impossibile parsare 'orderDocDate' '{order_doc_date_str}'. Verrà usata la stringa originale.")
         
         due_date_formatted = None
-        if due_date_str: 
+        if due_date_str:
             try:
                 dt_object = datetime.fromisoformat(due_date_str.replace('Z', ''))
                 due_date_formatted = dt_object.strftime('%d/%m/%Y')
             except ValueError:
-                due_date_formatted = due_date_str
+                due_date_formatted = due_date_str # Usa la stringa originale se il parsing fallisce
                 st.warning(f"Attenzione: Impossibile parsare 'orderDate' (dueDate) '{due_date_str}'. Verrà usata la stringa originale.")
 
         details = outbound_info.get('details', [])
 
         processed_data_for_this_file = []
         for item in details:
-            # Logica per cancelPosOda
-            cancel_pos_oda_value = item.get('cancelPosOda', False) # Assume default a False se non presente
-            cancel_pos_oda_excel = 'X' if cancel_pos_oda_value is True else '' # Metti 'X' se True, altrimenti vuoto
-
             row = {
                 'siteCode': site_code_json,
                 'companyCode': company_code_json,
                 'orderNumber': order_number,
-                'orderType': order_type_json, 
-                'deliveryType': delivery_type_fixed, 
-                'orderDate': order_date_formatted, 
-                'dateDetail': date_detail_json, 
+                'orderType': order_type_json,
+                'deliveryType': delivery_type_fixed,
+                'orderDate': order_date_formatted,
+                'dateDetail': date_detail_json,
                 'dueDate': due_date_formatted,
                 'reasonCode': reason_code,
-                'paymentValue': payment_info_value, 
+                'paymentValue': payment_info_value,
                 'customer.code': customer_code,
-                'customer.name': customer_name, 
-                'customer.address': customer_address, 
-                'customer.city': customer_city, 
-                'customer.province': customer_province, 
-                'customer.zipCode': customer_zip_code, 
-                'customer.country': customer_country, 
-                'consignee.name': consignee_name, 
-                'consignee.address': consignee_address, 
-                'consignee.city': consignee_city, 
-                'consignee.province': consignee_province, 
-                'consignee.zipCode': consignee_zip_code, 
-                'consignee.country': consignee_country, 
-                'customer.mail': customer_mail, 
+                'customer.name': customer_name,
+                'customer.address': customer_address,
+                'customer.city': customer_city,
+                'customer.province': customer_province,
+                'customer.zipCode': customer_zip_code,
+                'customer.country': customer_country,
+                'consignee.name': consignee_name,
+                'consignee.address': consignee_address,
+                'consignee.city': consignee_city,
+                'consignee.province': consignee_province,
+                'consignee.zipCode': consignee_zip_code,
+                'consignee.country': consignee_country,
+                'customer.mail': customer_mail,
                 'details.positionId': item.get('positionId'),
-                'details.itemNumber': item.get('itemCode'), 
-                'details.requestedQt': item.get('quantity'), 
+                'details.itemNumber': item.get('itemCode'),
+                'details.requestedQt': item.get('quantity'),
                 'details.lotId': item.get('lotId'),
                 'details.stockOwner': item.get('stockOwner'),
-                'details.magCli': item.get('warehouse'), 
+                'details.magCli': item.get('warehouse'),
                 'details.availability': item.get('availability'),
                 'details.accountingStatus': item.get('accountingStatus'),
                 'details.refOrder': item.get('refOrder'),
-                'cancelPosOda': cancel_pos_oda_excel, # Nuovo campo
-                'noteDDT': note_ddt, 
-                'noteMag': note_warehouse, 
+                'noteDDT': note_ddt,
+                'noteMag': note_warehouse,
                 'noteDelivery': note_delivery,
                 'noteShipment': note_shipment,
                 'reasonCodeShp': reason_code_shp,
@@ -214,7 +226,7 @@ def convert_json_to_excel_data_outbound(json_file_content: str, customers_df_inp
             processed_data_for_this_file.append(row)
 
         if not processed_data_for_this_file:
-            return pd.DataFrame() 
+            return pd.DataFrame() # Ritorna un DataFrame vuoto se non ci sono dettagli
 
         return pd.DataFrame(processed_data_for_this_file)
 
@@ -232,11 +244,17 @@ def convert_json_to_excel_data_outbound(json_file_content: str, customers_df_inp
 st.title("Convertitore JSON Outbound a Template Excel Outbound")
 st.write("Questo strumento converte uno o più file JSON di ordini Outbound in un unico foglio Excel formattato, utilizzando un'anagrafica partner esterna.")
 
-st.header("1. Carica Excel con Anagrafica Partner")
+---
+
+### 1. Carica Excel con Anagrafica Partner
+
+Qui puoi caricare il file Excel che contiene i dati dei tuoi clienti. È essenziale per arricchire le informazioni provenienti dai JSON.
+
+```python
 uploaded_customers_file = st.file_uploader(
     "Scegli il file Excel con l'anagrafica dei partner",
     type=["xlsx", "xls"],
-    accept_multiple_files=False, 
+    accept_multiple_files=False,
     key=st.session_state.file_uploader_key_customers
 )
 
@@ -246,12 +264,12 @@ customers_df = st.session_state.customers_df
 if uploaded_customers_file:
     try:
         # Leggi l'Excel partendo dalla riga 2 (indice 1) per le intestazioni
-        temp_customers_df = pd.read_excel(uploaded_customers_file, header=1) 
+        temp_customers_df = pd.read_excel(uploaded_customers_file, header=1)
         
         # Colonne richieste nell'Excel clienti
         required_excel_cols = [
-            'code', 'company.code', 'partner.name', 'partner.address.address', 
-            'partner.address.addressNumber', 'partner.address.city', 
+            'code', 'company.code', 'partner.name', 'partner.address.address',
+            'partner.address.addressNumber', 'partner.address.city',
             'partner.address.province', 'partner.address.zipCode', 'partner.address.country'
         ]
         
@@ -278,7 +296,13 @@ if uploaded_customers_file:
 # Aggiorna la variabile locale customers_df ogni volta che il session_state cambia
 customers_df = st.session_state.customers_df
 
-st.header("2. Carica i tuoi file JSON degli Ordini Outbound")
+---
+
+### 2. Carica i tuoi file JSON degli Ordini Outbound
+
+Qui puoi caricare uno o più file JSON. **Ricorda**: l'uploader è attivo solo dopo aver caricato un file Excel di anagrafica valido.
+
+```python
 uploaded_json_files = st.file_uploader(
     "Scegli uno o più file JSON di tipo 'Ordine_Outbound'",
     type=["json"],
@@ -297,10 +321,11 @@ if uploaded_json_files and st.session_state.customer_excel_loaded:
     for uploaded_file in uploaded_json_files:
         file_name = uploaded_file.name
         
+        # Verifica che il nome del file inizi con "Ordine_Outbound"
         if not file_name.lower().startswith("ordine_outbound"):
             st.error(f"Errore: Il file '{file_name}' non inizia con 'Ordine_Outbound'. Verrà ignorato.")
             has_blocking_error = True
-            continue
+            continue # Passa al prossimo file
         
         try:
             json_content_bytes = uploaded_file.read()
@@ -309,7 +334,7 @@ if uploaded_json_files and st.session_state.customer_excel_loaded:
             # Passa customers_df dallo session state alla funzione di conversione
             df_this_file = convert_json_to_excel_data_outbound(json_content_string, st.session_state.customers_df)
             
-            if df_this_file is not None and not df_this_file.empty: 
+            if df_this_file is not None and not df_this_file.empty:
                 all_processed_data.append(df_this_file)
             elif df_this_file is None: # Se la funzione ritorna None, c'è stato un errore bloccante
                 has_blocking_error = True
@@ -319,22 +344,24 @@ if uploaded_json_files and st.session_state.customer_excel_loaded:
             st.error(f"Si è verificato un errore imprevisto durante la lettura o l'elaborazione del file '{file_name}': {e}")
             has_blocking_error = True
 
+    # --- Generazione del file Excel finale ---
     if not has_blocking_error and all_processed_data:
+        # Concatena tutti i DataFrame elaborati in uno solo
         final_df = pd.concat(all_processed_data, ignore_index=True)
         st.success(f"Elaborazione di {len(all_processed_data)} file JSON completata! Pronto per il download.")
         
         # --- Post-processing per la formattazione Excel ---
         
-        # Definizione delle colonne di testata
+        # Definizione delle colonne di testata che devono essere azzerate per le righe duplicate dello stesso ordine
         header_columns = [
             'siteCode', 'companyCode', 'orderNumber', 'orderType', 'deliveryType',
             'orderDate', 'dateDetail', 'dueDate', 'reasonCode',
-            'paymentValue', 
+            'paymentValue',
             'customer.code', 'customer.name', 'customer.address', 'customer.city',
             'customer.province', 'customer.zipCode', 'customer.country',
             'consignee.name', 'consignee.address', 'consignee.city', 'consignee.province',
             'consignee.zipCode', 'consignee.country', 'customer.mail',
-            'noteDDT', 'noteMag', 'noteDelivery', 'noteShipment', 
+            'noteDDT', 'noteMag', 'noteDelivery', 'noteShipment',
             'reasonCodeShp', 'infoDelivery', 'bookingInfo'
         ]
 
@@ -344,23 +371,23 @@ if uploaded_json_files and st.session_state.customer_excel_loaded:
         # Crea una maschera booleana per identificare le righe duplicate per orderNumber
         rows_to_clear_headers = final_df.duplicated(subset=['orderNumber'], keep='first')
         
-        # Azzerare le colonne di testata per le righe identificate
+        # Azzerare le colonne di testata per le righe identificate (lascia solo la prima occorrenza)
         final_df.loc[rows_to_clear_headers, header_columns] = ""
 
         # --- Creazione file Excel ---
         output = io.BytesIO()
         writer = pd.ExcelWriter(output, engine='xlsxwriter')
         
-        sheet_name_excel = 'Delivery' # Nome del foglio modificato
+        sheet_name_excel = 'Delivery' # Nome del foglio Excel
 
         workbook = writer.book
-        worksheet = workbook.add_worksheet(sheet_name_excel) 
+        worksheet = workbook.add_worksheet(sheet_name_excel)
 
-        # Lista delle colonne finali nell'ordine desiderato (aggiunto 'cancelPosOda')
+        # Lista delle colonne finali nell'ordine desiderato per l'Excel
         final_columns_order = [
             'siteCode', 'companyCode', 'orderNumber', 'orderType', 'deliveryType',
             'orderDate', 'dateDetail', 'dueDate', 'reasonCode',
-            'paymentValue', 
+            'paymentValue',
             'customer.code', 'customer.name', 'customer.address', 'customer.city',
             'customer.province', 'customer.zipCode', 'customer.country',
             'consignee.name', 'consignee.address', 'consignee.city', 'consignee.province',
@@ -368,31 +395,30 @@ if uploaded_json_files and st.session_state.customer_excel_loaded:
             'details.positionId', 'details.itemNumber', 'details.requestedQt',
             'details.lotId', 'details.stockOwner', 'details.magCli', 'details.availability',
             'details.accountingStatus', 'details.refOrder',
-            'cancelPosOda', # Nuovo campo aggiunto qui
-            'noteDDT', 'noteMag', 'noteDelivery', 'noteShipment', 
+            'noteDDT', 'noteMag', 'noteDelivery', 'noteShipment',
             'reasonCodeShp', 'infoDelivery', 'bookingInfo'
         ]
         
         # Assicurati che il DataFrame abbia tutte le colonne nell'ordine desiderato
+        # Aggiungi colonne mancanti con valori vuoti
         for col in final_columns_order:
             if col not in final_df.columns:
-                final_df[col] = "" 
+                final_df[col] = ""
         final_df = final_df[final_columns_order]
 
-        # Larghezze delle colonne aggiornate (aggiunto 'cancelPosOda')
+        # Larghezze delle colonne aggiornate per l'Excel
         col_widths = {
             'siteCode': 10, 'companyCode': 15, 'orderNumber': 15, 'orderType': 10, 'deliveryType': 12,
-            'orderDate': 12, 'dateDetail': 15, 'dueDate': 12, 'reasonCode': 12, 
-            'paymentValue': 15, 
-            'customer.code': 15, 'customer.name': 30, 'customer.address': 30, 'customer.city': 15, 
+            'orderDate': 12, 'dateDetail': 15, 'dueDate': 12, 'reasonCode': 12,
+            'paymentValue': 15,
+            'customer.code': 15, 'customer.name': 30, 'customer.address': 30, 'customer.city': 15,
             'customer.province': 10, 'customer.zipCode': 10, 'customer.country': 10,
             'consignee.name': 30, 'consignee.address': 30, 'consignee.city': 15, 'consignee.province': 10,
             'consignee.zipCode': 10, 'consignee.country': 10, 'customer.mail': 25,
             'details.positionId': 12, 'details.itemNumber': 20, 'details.requestedQt': 15,
             'details.lotId': 10, 'details.stockOwner': 15, 'details.magCli': 15, 'details.availability': 15,
             'details.accountingStatus': 18, 'details.refOrder': 15,
-            'cancelPosOda': 10, # Larghezza per il nuovo campo
-            'noteDDT': 20, 'noteMag': 20, 'noteDelivery': 20, 'noteShipment': 20, 
+            'noteDDT': 20, 'noteMag': 20, 'noteDelivery': 20, 'noteShipment': 20,
             'reasonCodeShp': 15, 'infoDelivery': 20, 'bookingInfo': 20
         }
         
@@ -401,26 +427,27 @@ if uploaded_json_files and st.session_state.customer_excel_loaded:
 
         # Scrivi i nomi delle colonne nella riga 2 (indice 1 in xlsxwriter)
         for col_num, col_name in enumerate(final_df.columns.values):
-            worksheet.write(1, col_num, col_name) 
+            worksheet.write(1, col_num, col_name)
 
             # Imposta le larghezze delle colonne
             if col_name in col_widths:
                 worksheet.set_column(col_num, col_num, col_widths[col_name])
             else:
-                worksheet.set_column(col_num, col_num, 15) 
-            
+                worksheet.set_column(col_num, col_num, 15) # Larghezza di default
+
             # Applica il formato data alle colonne 'orderDate' e 'dueDate'
-            if col_name in ['orderDate', 'dueDate']: 
+            if col_name in ['orderDate', 'dueDate']:
                 worksheet.set_column(col_num, col_num, col_widths[col_name], date_format)
 
         # Scrivi i dati a partire dalla riga 3 (indice 2 in xlsxwriter)
         final_df.to_excel(writer, sheet_name=sheet_name_excel, index=False, header=False, startrow=2)
 
         writer.close()
-        output.seek(0)
+        output.seek(0) # Riporta il "puntatore" all'inizio del file BytesIO
 
+        # Genera un nome di file unico con timestamp
         timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
-        output_file_name = f"DeliveryOrders_{timestamp}.xlsx" # Nome del file di output
+        output_file_name = f"DeliveryOrders_{timestamp}.xlsx"
 
         st.download_button(
             label="Scarica file Excel Unificato",
@@ -435,10 +462,20 @@ if uploaded_json_files and st.session_state.customer_excel_loaded:
     else:
         st.info("Carica i tuoi file per iniziare.")
 
+---
+
+### Pulisci Input
+
+Questo pulsante ti permette di resettare l'applicazione e caricare nuovi file.
+
+```python
 # --- Funzione per il reset ---
 def clear_inputs():
+    """Resetta lo stato dell'applicazione, pulendo gli input e i dati caricati."""
+    # Aggiorna le chiavi degli uploader per forzarne il reset visivo
     st.session_state.file_uploader_key_json = f'json_uploader_{datetime.now().timestamp()}'
-    st.session_state.file_uploader_key_customers = f'customers_uploader_{datetime.now().timestamp() + 1}' # Assicurati che le chiavi siano diverse
+    # Aggiungi un piccolo offset per assicurare che la chiave sia diversa
+    st.session_state.file_uploader_key_customers = f'customers_uploader_{datetime.now().timestamp() + 1}'
     st.session_state.customer_excel_loaded = False
     st.session_state.customers_df = pd.DataFrame() # Resetta il DataFrame dell'anagrafica