Update src/streamlit_app.py

src/streamlit_app.py

@@ -7,11 +7,14 @@ import os
 import pytz
 
 # --- Inizializzazione Session State ---
-# Chiavi uniche per i file uploader per evitare DuplicateWidgetID
 if 'file_uploader_key_json' not in st.session_state:
-    st.session_state.file_uploader_key_json = 'json_uploader_0' # Chiave unica
+    st.session_state.file_uploader_key_json = 'json_uploader_0'
 if 'file_uploader_key_customers' not in st.session_state:
-    st.session_state.file_uploader_key_customers = 'customers_uploader_0' # Chiave unica
+    st.session_state.file_uploader_key_customers = 'customers_uploader_0'
+if 'customer_excel_loaded' not in st.session_state:
+    st.session_state.customer_excel_loaded = False
+if 'customers_df' not in st.session_state:
+    st.session_state.customers_df = pd.DataFrame()
 
 # --- CSS personalizzato ---
 st.markdown(
@@ -43,12 +46,12 @@ st.markdown(
     unsafe_allow_html=True
 )
 
-# Definizione del fuso orario per l'Italia (per coerenza, anche se le date Outbound sembrano solo data)
+# Definizione del fuso orario (per coerenza, anche se le date Outbound sembrano solo data)
 ITALY_TIMEZONE = pytz.timezone("Europe/Rome")
 UTC_TIMEZONE = pytz.utc
 
 # Funzione di conversione per Outbound
-def convert_json_to_excel_data_outbound(json_file_content: str, customers_df: pd.DataFrame = None):
+def convert_json_to_excel_data_outbound(json_file_content: str, customers_df_input: pd.DataFrame = None):
     try:
         json_data = json.loads(json_file_content)
 
@@ -61,28 +64,24 @@ def convert_json_to_excel_data_outbound(json_file_content: str, customers_df: pd
         
         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') # JSON field name
-        date_detail_json = outbound_info.get('orderDateDetail') # JSON field name, becomes 'dateDetail'
-        due_date_str = outbound_info.get('orderDate') # JSON field name, becomes 'dueDate'
+        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')
-        # service_fixed = "PDB" # Rimosso
-        # service_type_fixed = "Standard" # Rimosso
-
-        payment_info_value = outbound_info.get('paymentInfo', {}).get('value') # JSON field name
+        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 dal JSON
+        customer_mail = delivery_customer.get('refMail') 
 
         # Consignee data (from JSON)
         consignee_name = delivery_customer.get('name')
         consignee_address_base = delivery_customer.get('address', '')
-        consignee_address_number = delivery_customer.get('addressNumber', '') # Nuovo campo da JSON
+        consignee_address_number = delivery_customer.get('addressNumber', '') 
         
-        # Concatenazione indirizzo e civico per consignee.address
         consignee_address = f"{consignee_address_base} {consignee_address_number}".strip() if consignee_address_base or consignee_address_number else ""
 
         consignee_city = delivery_customer.get('city')
@@ -92,25 +91,26 @@ def convert_json_to_excel_data_outbound(json_file_content: str, customers_df: pd
 
         # Customer data (from Excel lookup)
         customer_name = ""
-        customer_address = "" # Questo sarà concatenazione
+        customer_address = "" 
         customer_city = ""
         customer_province = ""
         customer_zip_code = ""
         customer_country = ""
         
-        # Esegui la lookup solo se customers_df è fornito e non vuoto
-        if customers_df is not None and not customers_df.empty and customer_code and company_code_json:
+        # 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)
-            customer_data = customers_df[
-                (customers_df['code'].astype(str) == str(customer_code)) & # Modificato da 'Code' a 'code'
-                (customers_df['company.code'].astype(str) == str(company_code_json))
+            # 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['company.code'].astype(str) == str(company_code_json))
             ]
 
             if not customer_data.empty:
                 customer_row = customer_data.iloc[0]
                 customer_name = customer_row.get('partner.name', '')
                 
-                # Concatenazione partner.address.address e partner.address.addressNumber
                 excel_customer_address_base = customer_row.get('partner.address.address', '')
                 excel_customer_address_number = customer_row.get('partner.address.addressNumber', '')
                 customer_address = f"{excel_customer_address_base} {excel_customer_address_number}".strip() if excel_customer_address_base or excel_customer_address_number else ""
@@ -120,11 +120,20 @@ def convert_json_to_excel_data_outbound(json_file_content: str, customers_df: pd
                 customer_zip_code = customer_row.get('partner.address.zipCode', '')
                 customer_country = customer_row.get('partner.address.country', '')
             else:
-                st.warning(f"Attenzione: Dettagli cliente non trovati nell'Excel per Code: '{customer_code}' e Company: '{company_code_json}'.")
+                # Errore bloccante se l'anagrafica non viene trovata
+                st.error(f"ERRORE: Manca anagrafica per customer.code '{customer_code}' e company.code '{company_code_json}' nel file Excel dei clienti. Impossibile procedere con questo JSON.")
+                return None # Ritorna None per indicare un errore bloccante
+
+        elif not customer_code or not company_code_json:
+            st.warning(f"Attenzione: Customer Code o Company Code mancante nel JSON per l'ordine '{order_number}'. Impossibile effettuare la lookup sull'Excel.")
+        
+        elif customers_df_input is None or customers_df_input.empty:
+            st.error("ERRORE: Il file Excel dell'anagrafica partner non è stato caricato o è vuoto. Caricare prima l'anagrafica.")
+            return None # Errore bloccante se l'Excel clienti non è disponibile
 
         # Note fields
-        note_ddt = outbound_info.get('noteDdt') # JSON field name
-        note_warehouse = outbound_info.get('noteWarehouse') # JSON field name
+        note_ddt = outbound_info.get('noteDdt') 
+        note_warehouse = outbound_info.get('noteWarehouse') 
         
         note_delivery = outbound_info.get('noteDelivery')
         note_shipment = outbound_info.get('noteShipment')
@@ -133,7 +142,7 @@ def convert_json_to_excel_data_outbound(json_file_content: str, customers_df: pd
         booking_info = outbound_info.get('bookingInfo')
 
         # Formattazione delle date
-        order_date_formatted = None # Cambiato nome variabile
+        order_date_formatted = None 
         if order_doc_date_str:
             try:
                 dt_object = datetime.fromisoformat(order_doc_date_str.replace('Z', ''))
@@ -161,27 +170,25 @@ def convert_json_to_excel_data_outbound(json_file_content: str, customers_df: pd
                 'orderNumber': order_number,
                 'orderType': order_type_json, 
                 'deliveryType': delivery_type_fixed, 
-                'orderDate': order_date_formatted, # Cambiato nome colonna
-                'dateDetail': date_detail_json, # Cambiato nome colonna
+                'orderDate': order_date_formatted, 
+                'dateDetail': date_detail_json, 
                 'dueDate': due_date_formatted,
                 'reasonCode': reason_code,
-                # 'service': service_fixed, # Rimosso
-                # 'serviceType': service_type_fixed, # Rimosso
-                'paymentValue': payment_info_value, # Cambiato nome colonna
+                'paymentValue': payment_info_value, 
                 'customer.code': customer_code,
-                'customer.name': customer_name, # Da Excel
-                'customer.address': customer_address, # Da Excel (concatenato)
-                'customer.city': customer_city, # Da Excel
-                'customer.province': customer_province, # Da Excel
-                'customer.zipCode': customer_zip_code, # Da Excel
-                'customer.country': customer_country, # Da Excel
-                'consignee.name': consignee_name, # Dal JSON
-                'consignee.address': consignee_address, # Dal JSON (concatenato)
-                'consignee.city': consignee_city, # Dal JSON
-                'consignee.province': consignee_province, # Dal JSON
-                'consignee.zipCode': consignee_zip_code, # Dal JSON
-                'consignee.country': consignee_country, # Dal JSON
-                'customer.mail': customer_mail, # Dal JSON
+                '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'), 
@@ -191,8 +198,8 @@ def convert_json_to_excel_data_outbound(json_file_content: str, customers_df: pd
                 'details.availability': item.get('availability'),
                 'details.accountingStatus': item.get('accountingStatus'),
                 'details.refOrder': item.get('refOrder'),
-                'noteDDT': note_ddt, # Cambiato nome colonna
-                'noteMag': note_warehouse, # Cambiato nome colonna
+                'noteDDT': note_ddt, 
+                'noteMag': note_warehouse, 
                 'noteDelivery': note_delivery,
                 'noteShipment': note_shipment,
                 'reasonCodeShp': reason_code_shp,
@@ -218,70 +225,96 @@ def convert_json_to_excel_data_outbound(json_file_content: str, customers_df: pd
 
 # --- Interfaccia Streamlit ---
 st.title("Convertitore JSON Outbound a Template Excel Outbound")
-st.write("Carica i tuoi file JSON degli ordini Outbound e un file Excel con i dati dei clienti.")
+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 il file Excel dei Clienti")
-st.info("Questo file Excel deve contenere le colonne: `code`, `company.code`, `partner.name`, `partner.address.address`, `partner.address.addressNumber`, `partner.address.city`, `partner.address.province`, `partner.address.zipCode`, `partner.address.country`.")
+st.header("1. Carica Excel con Anagrafica Partner")
 uploaded_customers_file = st.file_uploader(
-    "Scegli il file Excel con i dettagli dei Clienti",
+    "Scegli il file Excel con l'anagrafica dei partner",
     type=["xlsx", "xls"],
-    accept_multiple_files=False, # Limitato a un solo file
+    accept_multiple_files=False, 
     key=st.session_state.file_uploader_key_customers
 )
 
-customers_df = pd.DataFrame()
+# Inizializza customers_df per il contesto corrente del rerun
+customers_df = st.session_state.customers_df
+
 if uploaded_customers_file:
     try:
-        customers_df = pd.read_excel(uploaded_customers_file)
-        # Assicurati che le colonne per il merge siano stringhe per evitare problemi di tipo
-        customers_df['code'] = customers_df['code'].astype(str) # Modificato da 'Code' a 'code'
-        customers_df['company.code'] = customers_df['company.code'].astype(str)
-        st.success("File Excel Clienti caricato con successo.")
+        # Leggi l'Excel partendo dalla riga 2 (indice 1) per le intestazioni
+        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', 
+            'partner.address.province', 'partner.address.zipCode', 'partner.address.country'
+        ]
+        
+        # Verifica che tutte le colonne richieste siano presenti
+        missing_cols = [col for col in required_excel_cols if col not in temp_customers_df.columns]
+        
+        if missing_cols:
+            st.error(f"Errore: Il file Excel dell'anagrafica partner manca le seguenti colonne essenziali: {', '.join(missing_cols)}. Caricare un file corretto.")
+            st.session_state.customer_excel_loaded = False
+            st.session_state.customers_df = pd.DataFrame() # Resetta il DF in caso di errore
+        else:
+            # Assicurati che le colonne per il merge siano stringhe per evitare problemi di tipo
+            temp_customers_df['code'] = temp_customers_df['code'].astype(str)
+            temp_customers_df['company.code'] = temp_customers_df['company.code'].astype(str)
+            st.session_state.customers_df = temp_customers_df # Salva il DF nello session_state
+            st.session_state.customer_excel_loaded = True
+            st.success("File Excel Anagrafica Partner caricato con successo e verificato.")
+            customers_df = st.session_state.customers_df # Aggiorna la variabile locale
     except Exception as e:
-        st.error(f"Errore nel caricamento del file Excel Clienti: {e}. Assicurati che sia un file Excel valido e che le colonne siano corrette.")
-        customers_df = pd.DataFrame()
+        st.error(f"Errore nel caricamento del file Excel Anagrafica Partner: {e}. Assicurati che sia un file Excel valido e che le intestazioni siano sulla seconda riga.")
+        st.session_state.customer_excel_loaded = False
+        st.session_state.customers_df = pd.DataFrame() # Resetta il DF in caso di errore
+
+# 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")
 uploaded_json_files = st.file_uploader(
     "Scegli uno o più file JSON di tipo 'Ordine_Outbound'",
     type=["json"],
     accept_multiple_files=True,
-    key=st.session_state.file_uploader_key_json
+    key=st.session_state.file_uploader_key_json,
+    disabled=not st.session_state.customer_excel_loaded # Disabilita se l'Excel non è stato caricato
 )
 
 all_processed_data = []
+# Flag per tracciare se c'è stato un errore bloccante nella conversione di qualsiasi JSON
+has_blocking_error = False
 
-if uploaded_json_files and not customers_df.empty:
+if uploaded_json_files and st.session_state.customer_excel_loaded:
     st.info(f"Caricati {len(uploaded_json_files)} file JSON. Elaborazione in corso...")
     
-    conversion_successful = True
-    
     for uploaded_file in uploaded_json_files:
         file_name = uploaded_file.name
         
         if not file_name.lower().startswith("ordine_outbound"):
             st.error(f"Errore: Il file '{file_name}' non inizia con 'Ordine_Outbound'. Verrà ignorato.")
-            conversion_successful = False
+            has_blocking_error = True
             continue
         
         try:
             json_content_bytes = uploaded_file.read()
             json_content_string = json_content_bytes.decode('utf-8')
 
-            # Passa customers_df alla funzione di conversione
-            df_this_file = convert_json_to_excel_data_outbound(json_content_string, customers_df)
+            # 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: 
                 all_processed_data.append(df_this_file)
-            elif df_this_file is None:
-                conversion_successful = False
-                st.error(f"Impossibile convertire il file '{file_name}'. Controlla i log per i dettagli.")
+            elif df_this_file is None: # Se la funzione ritorna None, c'è stato un errore bloccante
+                has_blocking_error = True
+                # Il messaggio di errore specifico è già gestito all'interno di convert_json_to_excel_data_outbound
                     
         except Exception as e:
             st.error(f"Si è verificato un errore imprevisto durante la lettura o l'elaborazione del file '{file_name}': {e}")
-            conversion_successful = False
+            has_blocking_error = True
 
-    if all_processed_data:
+    if not has_blocking_error and all_processed_data:
         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.")
         
@@ -291,13 +324,12 @@ if uploaded_json_files and not customers_df.empty:
         header_columns = [
             'siteCode', 'companyCode', 'orderNumber', 'orderType', 'deliveryType',
             'orderDate', 'dateDetail', 'dueDate', 'reasonCode',
-            # 'service', 'serviceType', # Rimosso
             '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', # Modificati
+            'noteDDT', 'noteMag', 'noteDelivery', 'noteShipment', 
             'reasonCodeShp', 'infoDelivery', 'bookingInfo'
         ]
 
@@ -314,16 +346,15 @@ if uploaded_json_files and not customers_df.empty:
         output = io.BytesIO()
         writer = pd.ExcelWriter(output, engine='xlsxwriter')
         
-        sheet_name_excel = 'OutboundOrder'
+        sheet_name_excel = 'Delivery' # Nome del foglio modificato
 
         workbook = writer.book
-        worksheet = workbook.add_worksheet(sheet_name_excel) # Creiamo sempre un nuovo worksheet
+        worksheet = workbook.add_worksheet(sheet_name_excel) 
 
         # Lista delle colonne finali nell'ordine desiderato
         final_columns_order = [
             'siteCode', 'companyCode', 'orderNumber', 'orderType', 'deliveryType',
             'orderDate', 'dateDetail', 'dueDate', 'reasonCode',
-            # 'service', 'serviceType', # Rimosso
             'paymentValue', 
             'customer.code', 'customer.name', 'customer.address', 'customer.city',
             'customer.province', 'customer.zipCode', 'customer.country',
@@ -332,24 +363,21 @@ if uploaded_json_files and not customers_df.empty:
             'details.positionId', 'details.itemNumber', 'details.requestedQt',
             'details.lotId', 'details.stockOwner', 'details.magCli', 'details.availability',
             'details.accountingStatus', 'details.refOrder',
-            'noteDDT', 'noteMag', 'noteDelivery', 'noteShipment', # Modificati
+            'noteDDT', 'noteMag', 'noteDelivery', 'noteShipment', 
             'reasonCodeShp', 'infoDelivery', 'bookingInfo'
         ]
         
         # Assicurati che il DataFrame abbia tutte le colonne nell'ordine desiderato
-        # Se una colonna non esiste nel DataFrame, la aggiungiamo vuota
         for col in final_columns_order:
             if col not in final_df.columns:
                 final_df[col] = "" 
-        # Riordina le colonne del DataFrame
         final_df = final_df[final_columns_order]
 
-        # Larghezze delle colonne aggiornate (adattate per Outbound)
+        # Larghezze delle colonne aggiornate
         col_widths = {
             'siteCode': 10, 'companyCode': 15, 'orderNumber': 15, 'orderType': 10, 'deliveryType': 12,
-            'orderDate': 12, 'dateDetail': 15, 'dueDate': 12, 'reasonCode': 12, # Date solo gg/mm/aaaa
-            # 'service': 10, 'serviceType': 12, # Rimosso
-            'paymentValue': 15, # Modificato
+            '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,
@@ -357,11 +385,11 @@ if uploaded_json_files and not customers_df.empty:
             '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, # Modificati
+            'noteDDT': 20, 'noteMag': 20, 'noteDelivery': 20, 'noteShipment': 20, 
             'reasonCodeShp': 15, 'infoDelivery': 20, 'bookingInfo': 20
         }
         
-        # Formato data per le colonne di data (solo data, senza ora)
+        # Formato data per le colonne di data
         date_format = workbook.add_format({'num_format': 'dd/mm/yyyy'})
 
         # Scrivi i nomi delle colonne nella riga 2 (indice 1 in xlsxwriter)
@@ -375,7 +403,7 @@ if uploaded_json_files and not customers_df.empty:
                 worksheet.set_column(col_num, col_num, 15) 
             
             # Applica il formato data alle colonne 'orderDate' e 'dueDate'
-            if col_name in ['orderDate', 'dueDate']: # Modificato 'orderDocDate' in 'orderDate'
+            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)
@@ -385,7 +413,7 @@ if uploaded_json_files and not customers_df.empty:
         output.seek(0)
 
         timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
-        output_file_name = f"OutboundOrders_{timestamp}.xlsx"
+        output_file_name = f"DeliveryOrders_{timestamp}.xlsx" # Nome del file di output
 
         st.download_button(
             label="Scarica file Excel Unificato",
@@ -393,19 +421,19 @@ if uploaded_json_files and not customers_df.empty:
             file_name=output_file_name,
             mime="application/vnd.openxmlformats-officedocument.spreadsheetml.sheet"
         )
-    elif uploaded_json_files and customers_df.empty:
-        st.warning("Per elaborare i file JSON, devi prima caricare un file Excel con i dettagli dei clienti.")
-    elif not conversion_successful:
-        st.error("Nessun file valido è stato elaborato con successo. Controlla i messaggi di errore sopra.")
+    elif uploaded_json_files and has_blocking_error:
+        st.error("Si sono verificati errori bloccanti durante l'elaborazione dei JSON. Correggere gli errori per generare il file.")
+    elif uploaded_json_files and not st.session_state.customer_excel_loaded:
+        st.warning("Per elaborare i file JSON, devi prima caricare e validare un file Excel con l'anagrafica partner.")
     else:
-        st.info("Carica i tuoi file JSON per iniziare.")
+        st.info("Carica i tuoi file per iniziare.")
 
 # --- Funzione per il reset ---
 def clear_inputs():
-    # Per forzare il reset del file uploader, cambiamo la sua chiave
-    # Usiamo un timestamp per generare una chiave sempre nuova e unica
     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()}'
+    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
 
 st.markdown("---")
 st.button("Pulisci Input (RESET)", on_click=clear_inputs)