Update app.py

app.py

@@ -1,3 +1,4 @@
+# -*- coding: utf-8 -*-
 import gradio as gr
 import sqlite3
 import datetime
@@ -84,9 +85,8 @@ def db_query(query, params=()):
 
 # --- Business Logic Functions ---
 
-# **FIXED:** Helper to get product data as List of Lists (for DataFrame value)
 def get_products_for_display_lol():
-    """Get product data as list of lists (data only) for DataFrame."""
+    """Get product data as a list of lists (data only) for DataFrame."""
     products = db_query("SELECT id, name, price, stock FROM products ORDER BY name")
     if not products:
         return []
@@ -94,18 +94,15 @@ def get_products_for_display_lol():
     data = [[p.get('id', ''), p.get('name', ''), p.get('price', 0.0), p.get('stock', 0)] for p in products]
     return data
 
-# **FIXED:** add_product now returns gr.update with list of lists for the DataFrame
 def add_product(product_id, name, price_str, stock_str):
     """Adds a product to the database."""
     status_msg = ""
     # Validate input first
     if not all([product_id, name, price_str, stock_str]):
         status_msg = "Error: All product fields must be filled."
-        # Still return update for the table for consistency
         return status_msg, gr.update(value=get_products_for_display_lol())
 
     try:
-        # Convert price and stock, handle potential errors
         price_float = float(price_str)
         stock_int = int(stock_str)
     except (ValueError, TypeError):
@@ -117,56 +114,47 @@ def add_product(product_id, name, price_str, stock_str):
         return status_msg, gr.update(value=get_products_for_display_lol())
 
     # Proceed with INSERT query
-    # NOTE: This still only ADDS. To make it "Add/Update", more logic is needed.
     query = "INSERT INTO products (id, name, price, stock) VALUES (?, ?, ?, ?)"
     result = db_execute(query, (product_id, name, price_float, stock_int))
 
     if result is not None:
         status_msg = f"Product '{name}' added successfully."
     else:
-        # Possibility: ID already exists (PRIMARY KEY constraint)
         check_id = db_query("SELECT id FROM products WHERE id = ?", (product_id,))
         if check_id:
             status_msg = f"Error: Product ID '{product_id}' already exists."
         else:
             status_msg = "Error: Failed to add product to the database."
 
-    # Get the latest product list in list-of-lists format
     updated_product_list_data = get_products_for_display_lol()
-
     # Return status AND the update object for the DataFrame using list of lists
     return status_msg, gr.update(value=updated_product_list_data)
 
-# **FIXED:** Function to get choices as list[tuple] for INITIAL dropdown load
+
 def get_product_choices_initial():
     """Gets product choices as list[tuple] for initial dropdown load."""
     products = db_query("SELECT id, name, price, stock FROM products WHERE stock > 0 ORDER BY name")
     choices = []
     if products:
         try:
-             # Format: [(display_name, value), ...]
              choices = [(f"{p.get('name', 'N/A')} (Stock: {p.get('stock', 0)}, Price: {p.get('price', 0):.2f})", p.get('id'))
                         for p in products if isinstance(p, dict) and p.get('id')]
         except Exception as e:
              print(f"Error formatting initial choices: {e}")
              choices = []
-    # print("DEBUG: Initial choices for dropdown:", choices) # Keep commented unless debugging
     return choices # Return the raw list[tuple]
 
-# **FIXED:** Function returns gr.update object for DYNAMIC dropdown updates
+
 def get_product_choices_for_update():
     """Gets product choices and returns a Gradio update object for the Dropdown."""
     choices = get_product_choices_initial() # Reuse the logic to get list[tuple]
-    print("DEBUG: New choices for dropdown update:", choices) # Keep commented unless debugging
     # Return the update object with the new choices
     return gr.update(choices=choices)
 
 
 def get_product_details(product_id):
      """Get details for a single product."""
-     # Ensure product_id is a string
      if not isinstance(product_id, str):
-         # print(f"DEBUG: Invalid product_id type received: {type(product_id)}, value: {repr(product_id)}")
          return None
      result = db_query("SELECT id, name, price, stock FROM products WHERE id = ?", (product_id,))
      return result[0] if result else None
@@ -174,21 +162,21 @@ def get_product_details(product_id):
 def process_sale(cart_items, amount_paid_str):
     """Process the sale, save to DB, update stock."""
     if not cart_items:
-        return "Cart is empty.", ""
+        return "Cart is empty.", "" # Return empty receipt string on error
 
     try:
         amount_paid = float(amount_paid_str)
         if amount_paid < 0: raise ValueError("Paid amount cannot be negative")
     except (ValueError, TypeError):
-        return "Invalid amount paid.", ""
+        return "Invalid amount paid.", "" # Return empty receipt string on error
 
     total_amount = sum(item['subtotal'] for item in cart_items)
 
     if amount_paid < total_amount:
-        return f"Amount paid ({amount_paid:,.2f}) is less than the total amount ({total_amount:,.2f}).", ""
+        return f"Amount paid ({amount_paid:,.2f}) is less than the total amount ({total_amount:,.2f}).", "" # Return empty receipt string
 
     change = amount_paid - total_amount
-    transaction_id = f"TRX-{uuid.uuid4().hex[:8].upper()}" # Unique ID
+    transaction_id = f"TRX-{uuid.uuid4().hex[:8].upper()}"
     timestamp = datetime.datetime.now().strftime("%Y-%m-%d %H:%M:%S")
 
     # --- Save to Database (within a single DB transaction) ---
@@ -210,12 +198,8 @@ def process_sale(cart_items, amount_paid_str):
         items_data = []
         for item in cart_items:
             items_data.append((
-                transaction_id,
-                item['id'],
-                item['nama'], # Use name/price stored in cart item
-                item['harga'],
-                item['jumlah'],
-                item['subtotal']
+                transaction_id, item['id'], item['nama'], item['harga'],
+                item['jumlah'], item['subtotal']
             ))
         cursor.executemany(item_insert_query, items_data)
 
@@ -223,7 +207,6 @@ def process_sale(cart_items, amount_paid_str):
         update_stock_query = "UPDATE products SET stock = stock - ? WHERE id = ?"
         stock_updates = []
         for item in cart_items:
-             # Re-validate stock before update
              current_stock_row = cursor.execute("SELECT stock FROM products WHERE id = ?", (item['id'],)).fetchone()
              if not current_stock_row or current_stock_row[0] < item['jumlah']:
                  item_name_for_error = item.get('nama', 'Unknown Item')
@@ -249,16 +232,17 @@ def process_sale(cart_items, amount_paid_str):
         receipt += "------------------------\n"
         receipt += "      Thank You!      \n"
 
+        # Return SUCCESS status and the generated receipt
         return f"Transaction Successful! Change: {change:,.2f}", receipt
 
     except sqlite3.Error as e:
         conn.rollback()
         print(f"Database Error during transaction: {e}")
-        return f"Error saving transaction: {e}", ""
+        return f"Error saving transaction: {e}", "" # Return empty receipt string on DB error
     except ValueError as e: # Catch stock validation error
          conn.rollback()
          print(f"Validation Error during transaction: {e}")
-         return f"Error: {e}", ""
+         return f"Error: {e}", "" # Return empty receipt string on validation error
     finally:
         conn.close()
 
@@ -267,79 +251,66 @@ def process_sale(cart_items, amount_paid_str):
 
 def add_item_to_cart(selected_product_id, quantity, current_cart):
     """Adds item to the shopping cart state."""
-    # Check type, should be string from dropdown value
     if not isinstance(selected_product_id, str) or quantity <= 0:
-         # print(f"DEBUG: Invalid input type: ID={type(selected_product_id)}, Qty={type(quantity)}") # Keep commented unless debugging
          gr.Warning("Invalid product selection or quantity.")
-         return current_cart # No change if input invalid
+         return current_cart
 
-    product = get_product_details(selected_product_id) # selected_product_id SHOULD be the string ID
+    product = get_product_details(selected_product_id)
     if not product:
         gr.Warning(f"Product with ID '{selected_product_id}' not found.")
         return current_cart
 
-    # Check stock BEFORE adding/updating cart
     if quantity > product['stock']:
         gr.Warning(f"Insufficient stock for {product['name']} (available: {product['stock']}).")
         return current_cart
 
-    # Check if product already in cart, update quantity if so
     found = False
     for item in current_cart:
         if item['id'] == product['id']:
             new_quantity = item['jumlah'] + quantity
-            # Check combined quantity against stock
             if new_quantity > product['stock']:
                  gr.Warning(f"Total quantity in cart ({new_quantity}) exceeds stock for {product['name']} ({product['stock']}).")
-                 return current_cart # Don't add if exceeds stock
+                 return current_cart
             item['jumlah'] = new_quantity
             item['subtotal'] = item['harga'] * new_quantity
             found = True
             gr.Info(f"Quantity for {product['name']} updated to {new_quantity}.")
             break
 
-    # If product not found, add new item
     if not found:
         new_item = {
-            "id": product['id'],
-            "nama": product['name'], # Store name and price at time of adding
-            "harga": product['price'],
-            "jumlah": quantity,
-            "subtotal": product['price'] * quantity
+            "id": product['id'], "nama": product['name'], "harga": product['price'],
+            "jumlah": quantity, "subtotal": product['price'] * quantity
         }
         current_cart.append(new_item)
         gr.Info(f"{quantity} x {product['name']} added to cart.")
 
-    return current_cart # Return the updated cart state (list of dicts)
+    return current_cart
+
 
-# **FIXED:** display_cart_and_total returns list[list] for DataFrame value update
 def display_cart_and_total(cart_state):
     """Prepares cart data (list of lists) and total amount string."""
     if not cart_state:
-        return [], "Total: 0.00" # Return empty list and zero total if cart is empty
+        return [], "Total: 0.00"
 
-    # Format for gr.DataFrame value (list of lists)
     display_data_lol = []
     total = 0.0
     for item in cart_state:
-        # Ensure order matches headers: ["Product Name", "Quantity", "Unit Price", "Subtotal"]
         display_data_lol.append([
-            item.get('nama', 'N/A'),
-            item.get('jumlah', 0),
-            item.get('harga', 0.0),
-            item.get('subtotal', 0.0)
+            item.get('nama', 'N/A'), item.get('jumlah', 0),
+            item.get('harga', 0.0), item.get('subtotal', 0.0)
         ])
         total += item.get('subtotal', 0.0)
 
-    # Return the list of lists data and the formatted total string
     return display_data_lol, f"Total: {total:,.2f}"
 
-# **FIXED:** reset_cashier_ui now calls the function returning the correct update object
+# **FIXED:** reset_cashier_ui only resets inputs/state for the next transaction
 def reset_cashier_ui():
-     """Resets the cashier UI components after a transaction."""
-     # Return default values AND the update object for the dropdown
-     # Order MUST match the outputs list in the .then() call
-     return [], 1, "Total: 0.00", "", "", "", get_product_choices_for_update()
+     """Resets inputs/state for the next cashier transaction, keeps status/receipt."""
+     # Return values for: cart_state, quantity_input, total_display, payment_input, product_dropdown update object
+     # NO LONGER returns empty strings for status and receipt
+     return [], 1, "Total: 0.00", "", get_product_choices_for_update()
+
 
 # --- Build Gradio Interface ---
 init_db() # Ensure DB and tables are ready on app start
@@ -354,7 +325,7 @@ with gr.Blocks(title="Simple POS v1.0 (Gradio)", theme=gr.themes.Soft()) as demo
         with gr.TabItem("🛒 POS / Cashier"):
             with gr.Row():
                 with gr.Column(scale=1):
-                    # **FIXED:** Initialize dropdown choices with the function returning list[tuple]
+                    # Initialize dropdown choices using the initial function
                     product_dropdown = gr.Dropdown(
                         label="Select Product",
                         choices=get_product_choices_initial(), # Use initial choices function
@@ -365,21 +336,19 @@ with gr.Blocks(title="Simple POS v1.0 (Gradio)", theme=gr.themes.Soft()) as demo
 
                 with gr.Column(scale=2):
                     gr.Markdown("#### Shopping Cart")
-                    # **FIXED:** Define cart_display DataFrame with static headers
+                    # Define cart_display DataFrame with static headers
                     cart_display = gr.DataFrame(
                         headers=["Product Name", "Quantity", "Unit Price", "Subtotal"],
-                        value=[], # Start empty
-                        interactive=False,
-                        datatype=["str", "number", "number", "number"]
+                        value=[], interactive=False, datatype=["str", "number", "number", "number"]
                         )
                     total_display = gr.Textbox("Total: 0.00", label="Total Amount", interactive=False)
 
             with gr.Row():
-                 # Use type="text" for more flexible float input
                  payment_input = gr.Textbox(label="Amount Paid", interactive=True, type="text")
                  process_payment_btn = gr.Button("💰 Process Payment", variant="primary")
 
             with gr.Row():
+                # Define Status and Receipt textboxes
                 status_transaksi = gr.Textbox(label="Status", interactive=False)
                 receipt_display = gr.Textbox(label="Receipt", lines=10, interactive=False)
 
@@ -388,19 +357,17 @@ with gr.Blocks(title="Simple POS v1.0 (Gradio)", theme=gr.themes.Soft()) as demo
             with gr.Row():
                  product_id_input = gr.Textbox(label="Product ID")
                  product_name_input = gr.Textbox(label="Product Name")
-                 # Use Textbox for flexible price/stock input, convert in backend
                  product_price_input = gr.Textbox(label="Selling Price")
                  product_stock_input = gr.Textbox(label="Initial Stock")
             add_product_btn = gr.Button("Add Product", variant="primary")
             status_produk = gr.Textbox(label="Status", interactive=False)
             gr.Markdown("---")
             gr.Markdown("#### Available Products List")
-            # **FIXED:** Define product_display DataFrame with static headers & initial list[list] value
+            # Define product_display DataFrame with static headers & initial list[list] value
             product_display = gr.DataFrame(
                  headers=["ID", "Name", "Price", "Stock"],
                  value=get_products_for_display_lol(), # Initial data uses list of lists
-                 interactive=False,
-                 datatype=["str", "str", "number", "number"]
+                 interactive=False, datatype=["str", "str", "number", "number"]
                  )
 
 
@@ -414,20 +381,21 @@ with gr.Blocks(title="Simple POS v1.0 (Gradio)", theme=gr.themes.Soft()) as demo
     ).then( # Update the cart display & total AFTER state is updated
         fn=display_cart_and_total,
         inputs=[cart_state],
-         # **FIXED:** Map outputs (list[list], total_string) to component values
-        outputs=[cart_display, total_display]
+        outputs=[cart_display, total_display] # Update cart display value and total
     )
 
     process_payment_btn.click(
         fn=process_sale,
         inputs=[cart_state, payment_input],
-        outputs=[status_transaksi, receipt_display] # Update status and receipt
+        outputs=[status_transaksi, receipt_display] # Update status and receipt FIRST
     ).then( # Reset UI after payment process finishes
-        fn=reset_cashier_ui,
+        fn=reset_cashier_ui, # Calls the revised reset function
         inputs=[],
-         # **FIXED:** Map reset outputs to corresponding components, including dropdown update object
-        outputs=[cart_state, quantity_input, total_display, payment_input, status_transaksi, receipt_display, product_dropdown]
-    ).then( # Also update the cart display to empty after state reset
+         # **FIXED:** Map only the outputs returned by the new reset_cashier_ui
+         # Order must match its return: cart_state, quantity_input, total_display, payment_input, product_dropdown
+        outputs=[cart_state, quantity_input, total_display, payment_input, product_dropdown]
+         # status_transaksi and receipt_display are NOT included here, preserving their values
+    ).then( # Update cart display to empty after state reset (Keep this)
          fn=display_cart_and_total,
          inputs=[cart_state],
          outputs=[cart_display, total_display] # Update cart display value
@@ -438,8 +406,7 @@ with gr.Blocks(title="Simple POS v1.0 (Gradio)", theme=gr.themes.Soft()) as demo
     add_product_btn.click(
         fn=add_product,
         inputs=[product_id_input, product_name_input, product_price_input, product_stock_input],
-         # **FIXED:** Map add_product outputs (status, gr.update object for DataFrame)
-        outputs=[status_produk, product_display]
+        outputs=[status_produk, product_display] # Update status and product list DataFrame
     ).then( # Also update the product dropdown choices in the POS tab
         fn=get_product_choices_for_update, # Call function that returns gr.update object
         inputs=[],
@@ -451,5 +418,4 @@ if __name__ == "__main__":
     # Initial setup message
     print(f"Ensure the database file '{DB_FILE}' is writable in the current directory.")
     print("Launching Gradio application...")
-    # demo.launch(share=True) # To create a temporary public link via Gradio relay
     demo.launch() # Run on localhost