Update src/streamlit_app.py

src/streamlit_app.py

@@ -7,7 +7,6 @@ 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:
@@ -18,7 +17,6 @@ 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>
@@ -54,20 +52,6 @@ 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)
 
@@ -80,23 +64,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" # Valore fisso
+        delivery_type_fixed = "DELIVERY" 
 
-        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 - destinatario della merce)
+        # Consignee data (from JSON)
         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 ""
 
@@ -105,21 +89,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 - cliente effettivo che ha fatto l'ordine)
+        # Customer data (from Excel lookup)
         customer_name = ""
-        customer_address = ""
+        customer_address = "" 
         customer_city = ""
         customer_province = ""
         customer_zip_code = ""
         customer_country = ""
         
-        # Esegue la lookup solo se customers_df_input è fornito e non vuoto
+        # Esegui 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))
             ]
 
@@ -148,8 +132,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')
@@ -158,23 +142,22 @@ 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 # Usa la stringa originale se il parsing fallisce
+                order_date_formatted = order_doc_date_str
                 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 # Usa la stringa originale se il parsing fallisce
+                due_date_formatted = due_date_str
                 st.warning(f"Attenzione: Impossibile parsare 'orderDate' (dueDate) '{due_date_str}'. Verrà usata la stringa originale.")
 
         details = outbound_info.get('details', [])
@@ -185,38 +168,38 @@ def convert_json_to_excel_data_outbound(json_file_content: str, customers_df_inp
                 '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'),
-                'noteDDT': note_ddt,
-                'noteMag': note_warehouse,
+                'noteDDT': note_ddt, 
+                'noteMag': note_warehouse, 
                 'noteDelivery': note_delivery,
                 'noteShipment': note_shipment,
                 'reasonCodeShp': reason_code_shp,
@@ -226,7 +209,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() # Ritorna un DataFrame vuoto se non ci sono dettagli
+            return pd.DataFrame() 
 
         return pd.DataFrame(processed_data_for_this_file)
 
@@ -244,17 +227,11 @@ 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.")
 
----
-
-### 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
+st.header("1. Carica Excel con Anagrafica Partner")
 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
 )
 
@@ -264,12 +241,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'
         ]
         
@@ -296,13 +273,7 @@ if uploaded_customers_file:
 # Aggiorna la variabile locale customers_df ogni volta che il session_state cambia
 customers_df = st.session_state.customers_df
 
----
-
-### 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
+st.header("2. Carica i tuoi file JSON degli Ordini Outbound")
 uploaded_json_files = st.file_uploader(
     "Scegli uno o più file JSON di tipo 'Ordine_Outbound'",
     type=["json"],
@@ -321,11 +292,10 @@ 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 # Passa al prossimo file
+            continue
         
         try:
             json_content_bytes = uploaded_file.read()
@@ -334,7 +304,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
@@ -344,24 +314,22 @@ 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 che devono essere azzerate per le righe duplicate dello stesso ordine
+        # Definizione delle colonne di testata
         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'
         ]
 
@@ -371,23 +339,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 (lascia solo la prima occorrenza)
+        # Azzerare le colonne di testata per le righe identificate
         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 Excel
+        sheet_name_excel = 'Delivery' # Nome del foglio modificato
 
         workbook = writer.book
-        worksheet = workbook.add_worksheet(sheet_name_excel)
+        worksheet = workbook.add_worksheet(sheet_name_excel) 
 
-        # Lista delle colonne finali nell'ordine desiderato per l'Excel
+        # Lista delle colonne finali nell'ordine desiderato
         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',
@@ -395,30 +363,29 @@ 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',
-            '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 per l'Excel
+        # Larghezze delle colonne aggiornate
         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,
-            'noteDDT': 20, 'noteMag': 20, 'noteDelivery': 20, 'noteShipment': 20,
+            'noteDDT': 20, 'noteMag': 20, 'noteDelivery': 20, 'noteShipment': 20, 
             'reasonCodeShp': 15, 'infoDelivery': 20, 'bookingInfo': 20
         }
         
@@ -427,27 +394,26 @@ 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) # Larghezza di default
-
+                worksheet.set_column(col_num, col_num, 15) 
+            
             # 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) # Riporta il "puntatore" all'inizio del file BytesIO
+        output.seek(0)
 
-        # 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"
+        output_file_name = f"DeliveryOrders_{timestamp}.xlsx" # Nome del file di output
 
         st.download_button(
             label="Scarica file Excel Unificato",
@@ -462,20 +428,10 @@ 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()}'
-    # 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.file_uploader_key_customers = f'customers_uploader_{datetime.now().timestamp() + 1}' # Assicurati che le chiavi siano diverse
     st.session_state.customer_excel_loaded = False
     st.session_state.customers_df = pd.DataFrame() # Resetta il DataFrame dell'anagrafica