Upload app.py

app.py

@@ -0,0 +1,488 @@
+import streamlit as st
+from pymongo import MongoClient
+from datetime import datetime
+import pandas as pd
+
+# MongoDB connection details
+MONGO_URI = "mongodb+srv://kmrlogistics:[email protected]/"
+DB_NAME = "trucking"
+COLLECTION_NAME_DRIVERS = "drivers"
+COLLECTION_NAME_TRUCKS = "trucks"
+COLLECTION_NAME_OWNER_OPERATORS = "owner_operators"
+
+# Establish a connection to MongoDB
+client = MongoClient(MONGO_URI)
+db = client[DB_NAME]
+drivers_collection = db[COLLECTION_NAME_DRIVERS]
+trucks_collection = db[COLLECTION_NAME_TRUCKS]
+owner_operators_collection = db[COLLECTION_NAME_OWNER_OPERATORS]
+
+# User authentication function
+def login(username, password):
+    """Check the provided username and password."""
+    return username == "KMR LOGISTICS" and password == "kmr2024"
+
+# Initialize Streamlit session state for login
+if "logged_in" not in st.session_state:
+    st.session_state.logged_in = False
+
+# Streamlit app layout
+st.title("Kmr Logistics Management")
+
+# Login section
+st.sidebar.header("User Login")
+
+if not st.session_state.logged_in:
+    username = st.sidebar.text_input("Username")
+    password = st.sidebar.text_input("Password", type="password")
+
+    if st.sidebar.button("Login"):
+        if login(username, password):
+            st.session_state.logged_in = True
+            st.sidebar.success("Logged in successfully!")
+        else:
+            st.sidebar.error("Invalid username or password.")
+else:
+    st.sidebar.success("Logged in as kmr logistics.")
+
+# Show the main application only if the user is logged in
+if st.session_state.logged_in:
+    # Page navigation
+    page = st.sidebar.selectbox("Select a page", [
+        "Add Truck",
+        "Add Driver",
+        "Add Owner Operator",
+        "Assign Truck",
+        "Add Load",
+        "Update/Delete Load",
+        "View Owner Operator Info",
+        "View Information"
+    ])
+
+    if page == "Add Truck":
+        st.header("Add Truck Information")
+        truck_name = st.text_input("Truck Name")
+        truck_plate_number = st.text_input("Truck Plate Number")
+
+        if st.button("Save Truck Info"):
+            if truck_name and truck_plate_number:
+                # Check if truck exists
+                existing_truck = trucks_collection.find_one({"truck_plate_number": truck_plate_number})
+                if existing_truck:
+                    st.warning(f"Truck with Plate Number {truck_plate_number} already exists.")
+                else:
+                    truck_data = {
+                        "truck_name": truck_name,
+                        "truck_plate_number": truck_plate_number
+                    }
+                    trucks_collection.insert_one(truck_data)
+                    st.success(f"Truck {truck_name} added successfully!")
+            else:
+                st.error("Please fill in all fields.")
+
+    elif page == "Add Driver":
+        st.header("Add Driver Information")
+        first_name = st.text_input("First Name")
+        last_name = st.text_input("Last Name")
+        contact_info = st.text_input("Contact Info")
+        pay_per_mile = st.number_input("Driver Pay per Mile", min_value=0.0, format="%f")
+
+        if st.button("Save Driver Info"):
+            if first_name and last_name and contact_info and pay_per_mile:
+                full_name = f"{first_name} {last_name}"
+
+                # Check if driver exists
+                existing_driver = drivers_collection.find_one({"contact_info": contact_info})
+                if existing_driver:
+                    st.warning(f"Driver with Contact Info {contact_info} already exists.")
+                else:
+                    driver_data = {
+                        "first_name": first_name,
+                        "last_name": last_name,
+                        "contact_info": contact_info,
+                        "pay_per_mile": pay_per_mile,
+                        "trucks": [],
+                        "loads": []
+                    }
+                    drivers_collection.insert_one(driver_data)
+                    st.success(f"Driver {full_name} added successfully!")
+            else:
+                st.error("Please fill in all fields.")
+
+    elif page == "Add Owner Operator":
+        st.header("Add Owner Operator")
+        name = st.text_input("Owner Operator Name")
+        contact_info = st.text_input("Contact Number")
+        company_percentage = st.number_input("Company Percentage", min_value=0.0, max_value=100.0, format="%f")
+
+        if st.button("Save Owner Operator Info"):
+            if name and contact_info and company_percentage:
+                # Check if owner operator exists
+                existing_owner_operator = owner_operators_collection.find_one({"contact_info": contact_info})
+                if existing_owner_operator:
+                    st.warning(f"Owner Operator with Contact Number {contact_info} already exists.")
+                else:
+                    owner_operator_data = {
+                        "name": name,
+                        "contact_info": contact_info,
+                        "company_percentage": company_percentage,
+                        "trucks": [],
+                        "loads": []
+                    }
+                    owner_operators_collection.insert_one(owner_operator_data)
+                    st.success(f"Owner Operator {name} added successfully!")
+            else:
+                st.error("Please fill in all fields.")
+
+    elif page == "Assign Truck":
+        st.header("Assign Truck to Driver or Owner Operator")
+        drivers = list(drivers_collection.find({}, {"first_name": 1, "last_name": 1}))
+        owner_operators = list(owner_operators_collection.find({}, {"name": 1}))
+
+        driver_names = [f"Driver: {d.get('first_name', '')} {d.get('last_name', '')}" for d in drivers]
+        owner_operator_names = [f"Owner Operator: {o.get('name', '')}" for o in owner_operators]
+
+        all_names = driver_names + owner_operator_names
+
+        selected_name = st.selectbox("Select Driver or Owner Operator", all_names)
+        trucks = list(trucks_collection.find({}, {"truck_name": 1, "truck_plate_number": 1}))
+        truck_names = [f"{t.get('truck_name', '')} ({t.get('truck_plate_number', '')})" for t in trucks]
+
+        selected_truck_name = st.selectbox("Select Truck", truck_names)
+
+        if st.button("Assign Truck"):
+            if selected_name and selected_truck_name:
+                selected_truck = next(t for t in trucks if f"{t.get('truck_name', '')} ({t.get('truck_plate_number', '')})" == selected_truck_name)
+                truck_plate_number = selected_truck["truck_plate_number"]
+
+                if selected_name.startswith("Driver:"):
+                    selected_driver = next(d for d in drivers if f"Driver: {d.get('first_name', '')} {d.get('last_name', '')}" == selected_name)
+                    # Update driver record to include truck
+                    drivers_collection.update_one(
+                        {"_id": selected_driver["_id"]},
+                        {"$addToSet": {"trucks": truck_plate_number}}
+                    )
+                    st.success(f"Truck {selected_truck_name} assigned to Driver {selected_name.split(': ')[1]} successfully!")
+
+                elif selected_name.startswith("Owner Operator:"):
+                    selected_owner_operator = next(o for o in owner_operators if f"Owner Operator: {o.get('name', '')}" == selected_name)
+                    # Update owner operator record to include truck
+                    owner_operators_collection.update_one(
+                        {"_id": selected_owner_operator["_id"]},
+                        {"$addToSet": {"trucks": truck_plate_number}}
+                    )
+                    st.success(f"Truck {selected_truck_name} assigned to Owner Operator {selected_name.split(': ')[1]} successfully!")
+            else:
+                st.error("Please select both a driver/owner operator and a truck.")
+
+    elif page == "Add Load":
+        st.header("Add Load Information")
+
+        # Fetch drivers, owner operators, and trucks
+        drivers = list(drivers_collection.find({}, {"first_name": 1, "last_name": 1, "trucks": 1, "contact_info": 1, "pay_per_mile": 1}))
+        owner_operators = list(owner_operators_collection.find({}, {"name": 1, "trucks": 1, "contact_info": 1, "company_percentage": 1}))
+
+        driver_names = [f"Driver: {d.get('first_name', '')} {d.get('last_name', '')}" for d in drivers]
+        owner_operator_names = [f"Owner Operator: {o.get('name', '')}" for o in owner_operators]
+
+        all_names = driver_names + owner_operator_names
+
+        selected_name = st.selectbox("Select Driver or Owner Operator", all_names)
+
+        if selected_name:
+            if selected_name.startswith("Driver:"):
+                selected_driver = next(d for d in drivers if f"Driver: {d.get('first_name', '')} {d.get('last_name', '')}" == selected_name)
+                truck_numbers = selected_driver.get('trucks', [])
+                entity_type = "driver"
+            elif selected_name.startswith("Owner Operator:"):
+                selected_owner_operator = next(o for o in owner_operators if f"Owner Operator: {o.get('name', '')}" == selected_name)
+                truck_numbers = selected_owner_operator.get('trucks', [])
+                entity_type = "owner_operator"
+
+            trucks_display = [
+                f"{t['truck_name']} ({t['truck_plate_number']})"
+                for t in trucks_collection.find({"truck_plate_number": {"$in": truck_numbers}})
+            ]
+
+            selected_truck_display = st.selectbox("Select Truck for Load", trucks_display)
+
+            if selected_truck_display:
+                selected_truck_no = selected_truck_display.split(" (")[1][:-1]
+
+                load_id = st.text_input("Load ID")
+                date_from = st.date_input("Date From", datetime.now())
+                date_to = st.date_input("Date To", datetime.now())
+                original_miles = st.number_input("Original Miles", min_value=0)
+                bobtail = st.number_input("Bobtail Miles", min_value=0)
+                payout = st.number_input("Payout", min_value=0.0, format="%f")
+                fuel_cost = st.number_input("Fuel Cost", min_value=0.0, format="%f")
+
+                actual_miles = original_miles - bobtail
+
+                if entity_type == "driver":
+                    driver_pay_per_mile = selected_driver.get("pay_per_mile", 0)
+                    driver_pay = actual_miles * driver_pay_per_mile
+                    final_payout = payout - driver_pay
+
+                elif entity_type == "owner_operator":
+                    company_percentage = selected_owner_operator.get("company_percentage", 0)
+                    pay_percent = (payout * company_percentage) / 100
+                    driver_pay = pay_percent
+                    final_payout = payout - pay_percent
+
+                if st.button("Save Load Info"):
+                    load_data = {
+                        "truck_no": selected_truck_no,
+                        "truck_name": selected_truck_display.split(" (")[0],
+                        "load_id": load_id,
+                        "date_from": date_from.strftime("%Y-%m-%d"),
+                        "date_to": date_to.strftime("%Y-%m-%d"),
+                        "original_miles": original_miles,
+                        "bobtail": bobtail,
+                        "actual_miles": actual_miles,
+                        "payout": payout,
+                        "fuel_cost": fuel_cost,
+                        "driver_pay": driver_pay,
+                        "final_payout": final_payout
+                    }
+
+                    if entity_type == "driver":
+                        drivers_collection.update_one(
+                            {"_id": selected_driver["_id"]},
+                            {"$push": {"loads": load_data}}
+                        )
+                        st.success(f"Load information added successfully for Driver {selected_driver.get('first_name', '')} {selected_driver.get('last_name', '')} with Truck {selected_truck_display.split(' (')[0]}!")
+                    
+                    elif entity_type == "owner_operator":
+                        owner_operators_collection.update_one(
+                            {"_id": selected_owner_operator["_id"]},
+                            {"$push": {"loads": load_data}}
+                        )
+                        st.success(f"Load information added successfully for Owner Operator {selected_owner_operator.get('name', '')} with Truck {selected_truck_display.split(' (')[0]}!")
+
+    elif page == "Update/Delete Load":
+        st.header("Update or Delete Load")
+
+        load_id = st.text_input("Enter Load ID to Update or Delete")
+
+        if load_id:
+            # Search for the load across all drivers and owner operators
+            driver_record = drivers_collection.find_one({"loads.load_id": load_id}, {"loads.$": 1, "first_name": 1, "last_name": 1})
+            owner_operator_record = owner_operators_collection.find_one({"loads.load_id": load_id}, {"loads.$": 1, "name": 1})
+            
+            if driver_record:
+                load_data = driver_record["loads"][0]
+                entity_type = "driver"
+                entity_name = f"{driver_record['first_name']} {driver_record['last_name']}"
+            elif owner_operator_record:
+                load_data = owner_operator_record["loads"][0]
+                entity_type = "owner_operator"
+                entity_name = owner_operator_record["name"]
+            else:
+                load_data = None
+
+            if load_data:
+                st.write(f"Load found for {entity_type.capitalize()}: {entity_name}")
+                
+                # Display load information
+                load_data_display = {
+                    "Truck No": load_data["truck_no"],
+                    "Load ID": load_data["load_id"],
+                    "Date From": load_data["date_from"],
+                    "Date To": load_data["date_to"],
+                    "Original Miles": load_data["original_miles"],
+                    "Bobtail Miles": load_data["bobtail"],
+                    "Payout": load_data["payout"],
+                    "Fuel Cost": load_data["fuel_cost"],
+                    "Driver/Owner Operator Pay": load_data["driver_pay"],
+                    "Final Payout": load_data["final_payout"]
+                }
+                
+                for key, value in load_data_display.items():
+                    st.write(f"{key}: {value}")
+                
+                # Input fields for updating the load
+                st.subheader("Update Load Information")
+                date_from = st.date_input("Date From", datetime.strptime(load_data["date_from"], "%Y-%m-%d"))
+                date_to = st.date_input("Date To", datetime.strptime(load_data["date_to"], "%Y-%m-%d"))
+                original_miles = st.number_input("Original Miles", value=load_data["original_miles"], min_value=0)
+                bobtail = st.number_input("Bobtail Miles", value=load_data["bobtail"], min_value=0)
+                payout = st.number_input("Payout", value=load_data["payout"], min_value=0.0, format="%f")
+                fuel_cost = st.number_input("Fuel Cost", value=load_data["fuel_cost"], min_value=0.0, format="%f")
+
+                actual_miles = original_miles - bobtail
+
+                if entity_type == "driver":
+                    driver_pay = actual_miles * driver_record["loads"][0]["driver_pay"] / load_data["actual_miles"]
+                    final_payout = payout - driver_pay
+
+                elif entity_type == "owner_operator":
+                    company_percentage = owner_operator_record["loads"][0].get("company_percentage", 0)
+                    pay_percent = (payout * company_percentage) / 100
+                    driver_pay = pay_percent
+                    final_payout = payout - pay_percent
+
+                if st.button("Update Load"):
+                    # Update the load with new values
+                    updated_load_data = {
+                        "loads.$.date_from": date_from.strftime("%Y-%m-%d"),
+                        "loads.$.date_to": date_to.strftime("%Y-%m-%d"),
+                        "loads.$.original_miles": original_miles,
+                        "loads.$.bobtail": bobtail,
+                        "loads.$.actual_miles": actual_miles,
+                        "loads.$.payout": payout,
+                        "loads.$.fuel_cost": fuel_cost,
+                        "loads.$.driver_pay": driver_pay,
+                        "loads.$.final_payout": final_payout
+                    }
+
+                    if entity_type == "driver":
+                        drivers_collection.update_one(
+                            {"_id": driver_record["_id"], "loads.load_id": load_id},
+                            {"$set": updated_load_data}
+                        )
+                        st.success(f"Load ID {load_id} updated successfully!")
+                    elif entity_type == "owner_operator":
+                        owner_operators_collection.update_one(
+                            {"_id": owner_operator_record["_id"], "loads.load_id": load_id},
+                            {"$set": updated_load_data}
+                        )
+                        st.success(f"Load ID {load_id} updated successfully!")
+
+                if st.button("Delete Load"):
+                    # Remove the load from the driver's or owner operator's record
+                    if entity_type == "driver":
+                        drivers_collection.update_one(
+                            {"_id": driver_record["_id"]},
+                            {"$pull": {"loads": {"load_id": load_id}}}
+                        )
+                        st.success(f"Load ID {load_id} deleted successfully!")
+                    elif entity_type == "owner_operator":
+                        owner_operators_collection.update_one(
+                            {"_id": owner_operator_record["_id"]},
+                            {"$pull": {"loads": {"load_id": load_id}}}
+                        )
+                        st.success(f"Load ID {load_id} deleted successfully!")
+            else:
+                st.warning(f"No load found with Load ID {load_id}.")
+
+    elif page == "View Owner Operator Info":
+        st.header("View Owner Operator Information")
+
+        owner_operators = list(owner_operators_collection.find({}))
+        owner_operator_names = [o.get('name', '') for o in owner_operators]
+
+        selected_owner_operator_name = st.selectbox("Select Owner Operator to View", owner_operator_names)
+
+        if selected_owner_operator_name:
+            owner_operator_record = owner_operators_collection.find_one({"name": selected_owner_operator_name})
+
+            if owner_operator_record:
+                st.write(f"**Name**: {owner_operator_record['name']}")
+                st.write(f"**Contact Number**: {owner_operator_record['contact_info']}")
+                st.write(f"**Company Percentage**: {owner_operator_record['company_percentage']}%")
+                st.write(f"**Trucks Assigned**: {', '.join(owner_operator_record['trucks']) if owner_operator_record['trucks'] else 'None'}")
+
+                # Date range input
+                date_from = st.date_input("Date From", datetime.now())
+                date_to = st.date_input("Date To", datetime.now())
+
+                # Convert the date input from Streamlit to Pandas datetime
+                date_from = pd.to_datetime(date_from)
+                date_to = pd.to_datetime(date_to)
+
+                # Display loads associated with this owner operator within the date range
+                if "loads" in owner_operator_record and owner_operator_record["loads"]:
+                    load_df = pd.DataFrame(owner_operator_record["loads"])
+                    load_df["date_from"] = pd.to_datetime(load_df["date_from"])
+                    load_df["date_to"] = pd.to_datetime(load_df["date_to"])
+
+                    # Filter by date range
+                    filtered_load_df = load_df[(load_df["date_from"] >= date_from) & (load_df["date_to"] <= date_to)]
+
+                    if not filtered_load_df.empty:
+                        st.subheader("Load Information")
+                        st.dataframe(filtered_load_df)
+
+                        # Total Calculations
+                        total_payout = filtered_load_df["payout"].sum()
+                        total_company_fee = filtered_load_df["driver_pay"].sum()
+                        total_final_payout = filtered_load_df["final_payout"].sum()
+                        total_fuel_cost = filtered_load_df["fuel_cost"].sum()
+                        total_final_payout_after_fuel = total_final_payout - total_fuel_cost
+
+                        st.subheader("Total Calculations")
+                        st.write(f"Total Payout: ${total_payout:.2f}")
+                        st.write(f"Total Company Fee: ${total_company_fee:.2f}")
+                        st.write(f"Total Final Payout after Fuel Cost: ${total_final_payout_after_fuel:.2f}")
+                        st.write(f"Total Fuel Cost: ${total_fuel_cost:.2f}")
+                    else:
+                        st.write("No loads found in the selected date range.")
+                else:
+                    st.write("No loads associated with this Owner Operator.")
+
+    elif page == "View Information":
+        st.header("View Load Information by Truck Name")
+
+        trucks = list(trucks_collection.find({}, {"truck_name": 1, "truck_plate_number": 1}))
+        truck_names = [f"{t.get('truck_name', '')} ({t.get('truck_plate_number', '')})" for t in trucks]
+
+        selected_truck_name_view = st.selectbox("Select Truck Name to View Records", truck_names)
+
+        if selected_truck_name_view:
+            truck_record = trucks_collection.find_one({"truck_name": selected_truck_name_view.split(" ")[0]})
+            if truck_record:
+                truck_plate_number = truck_record["truck_plate_number"]
+
+                date_from = st.date_input("Date From", datetime.now())
+                date_to = st.date_input("Date To", datetime.now())
+
+                # Filter load records for the selected truck and date range
+                loads_view = drivers_collection.aggregate([
+                    {"$match": {"trucks": truck_plate_number}},
+                    {"$unwind": "$loads"},
+                    {"$match": {
+                        "loads.truck_no": truck_plate_number,
+                        "loads.date_from": {"$gte": date_from.strftime("%Y-%m-%d")},
+                        "loads.date_to": {"$lte": date_to.strftime("%Y-%m-%d")}
+                    }}
+                ])
+
+                # Group loads by driver or owner operator
+                load_data_view = list(loads_view)
+                if load_data_view:
+                    # Create a dataframe for each driver/owner operator
+                    entity_data = {}
+                    for load in load_data_view:
+                        driver_name = f"{load['first_name']} {load['last_name']}" if "first_name" in load else load.get("name", "")
+                        if driver_name not in entity_data:
+                            entity_data[driver_name] = []
+                        entity_data[driver_name].append(load['loads'])
+
+                    for entity_name, loads in entity_data.items():
+                        st.subheader(f"Driver : {entity_name}")
+
+                        load_df = pd.DataFrame(loads)
+
+                        st.dataframe(load_df)
+
+                        total_original_miles = load_df["original_miles"].sum()
+                        total_actual_miles = load_df["actual_miles"].sum()
+                        total_payout = load_df["payout"].sum()
+                        total_driver_pay = load_df["driver_pay"].sum()
+                        total_fuel_cost = load_df["fuel_cost"].sum()
+
+                        st.subheader("Total Calculations")
+                        st.write(f"Total Original Miles: {total_original_miles}")
+                        st.write(f"Total Actual Miles: {total_actual_miles}")
+                        st.write(f"Total Payout: ${total_payout:.2f}")
+                        st.write(f"Total Pay to Driver: ${total_driver_pay:.2f}")
+                        st.write(f"Total Fuel Cost: ${total_fuel_cost:.2f}")
+
+                        # Option to save the results to a CSV file
+                        if st.button(f"Save Results to CSV for {entity_name}"):
+                            csv_filename = f"{entity_name.replace(' ', '_')}_load_data_summary.csv"
+                            load_df.to_csv(csv_filename, index=False)
+                            st.success(f"Results saved to {csv_filename}")
+                else:
+                    st.warning(f"No load records found for Truck {selected_truck_name_view.split(' ')[0]} between {date_from} and {date_to}.")