app.py

import os
import logging
from datetime import datetime
import pandas as pd
from dotenv import load_dotenv
from simple_salesforce import Salesforce
from fastapi import FastAPI
from fastapi.middleware.cors import CORSMiddleware
import gradio as gr
from transformers import pipeline

# Setup logging
logging.basicConfig(level=logging.INFO)
logger = logging.getLogger(__name__)

# Load environment variables
load_dotenv()
SF_USERNAME = os.getenv("SF_USERNAME")
SF_PASSWORD = os.getenv("SF_PASSWORD")
SF_SECURITY_TOKEN = os.getenv("SF_SECURITY_TOKEN")
SF_DOMAIN = os.getenv("SF_DOMAIN", "login")

# Hugging Face sentiment analysis model
sentiment_pipeline = pipeline("sentiment-analysis")

# FastAPI app
app = FastAPI()
app.add_middleware(
    CORSMiddleware,
    allow_origins=["*"],
    allow_credentials=True,
    allow_methods=["*"],
    allow_headers=["*"],
)

# Connect to Salesforce
def connect_to_salesforce():
    try:
        sf = Salesforce(
            username=SF_USERNAME,
            password=SF_PASSWORD,
            security_token=SF_SECURITY_TOKEN,
            domain=SF_DOMAIN
        )
        logger.info("Salesforce connected successfully.")
        return sf
    except Exception as e:
        logger.error(f"Salesforce login failed: {e}")
        return None

# Lookup Vendor ID by Name (assuming Vendor_Name__c references Vendor__c)
def get_vendor_id_by_name(sf, vendor_name):
    try:
        # Query the Vendor__c object (adjust object name if different, e.g., Account)
        query = f"SELECT Id FROM Vendor__c WHERE Name = '{vendor_name}' LIMIT 1"
        result = sf.query(query)
        if result["totalSize"] > 0:
            return result["records"][0]["Id"]
        else:
            logger.error(f"No vendor found with name: {vendor_name}")
            return None
    except Exception as e:
        logger.error(f"Error querying vendor ID for {vendor_name}: {e}")
        return None

# Save to Salesforce
def save_to_salesforce(data):
    sf = connect_to_salesforce()
    if not sf:
        return "Salesforce connection failed"
    try:
        vendor_name = data["vendor_name_id"]
        # Always look up the vendor ID by name
        vendor_id = get_vendor_id_by_name(sf, vendor_name)
        if not vendor_id:
            return f"Error: No vendor found with name '{vendor_name}'"

        result = sf.Vendor_Performance__c.create({
            "Vendor_ID__c": int(data["vendor_id"]),
            "Vendor_Name__c": vendor_id,  # Use the resolved ID
            "Score__c": data["score"],
            "Timeliness_Score__c": data["timeliness_score"],
            "Issue_Count__c": int(data["issue_score"] / 3),
            "Feedback_Rating__c": data["feedback_score"],
            "Evaluation_Date__c": data["evaluation_date"],
            "Rationale__c": data["rationale"]
        })
        logger.info(f"Record saved to Salesforce: {result}")
        return "Saved successfully"
    except Exception as e:
        logger.error(f"Save failed: {str(e)}")
        return f"Error: {str(e)}"

# Score vendor
def score_vendor(vendor_id, vendor_name_id, delivery_records, issue_counts, nps_values):
    if not vendor_id or not vendor_name_id:
        return {"error": "Vendor ID and Vendor Name are required."}
    if not (0 <= delivery_records <= 100):
        return {"error": "Delivery % must be 0–100"}
    if not (0 <= nps_values <= 100):
        return {"error": "NPS must be 0–100"}

    timeliness_score = round(delivery_records * 0.4, 2)
    issue_score = round((10 - min(issue_counts, 10)) * 3, 2)
    feedback_score = round(nps_values * 0.3, 2)
    total_score = round(timeliness_score + issue_score + feedback_score, 2)
    eval_date = datetime.today().strftime('%Y-%m-%d')
    rationale = f"Timeliness: {timeliness_score} + Issues: {issue_score} + Feedback: {feedback_score}"

    result = {
        "vendor_id": vendor_id,
        "vendor_name_id": vendor_name_id,
        "score": total_score,
        "timeliness_score": timeliness_score,
        "issue_score": issue_score,
        "feedback_score": feedback_score,
        "evaluation_date": eval_date,
        "rationale": rationale
    }

    save_status = save_to_salesforce(result)
    result["status"] = save_status
    return result

# Format for Gradio
def format_output(vendor_id, vendor_name_id, delivery_records, issue_counts, nps_values):
    result = score_vendor(vendor_id, vendor_name_id, delivery_records, issue_counts, nps_values)
    if "error" in result:
        return result["error"], None
    df = pd.DataFrame([result])
    return result["status"], df[[
        "vendor_id", "vendor_name_id", "score", "timeliness_score",
        "issue_score", "feedback_score", "evaluation_date", "rationale"
    ]]

# Batch CSV Upload
def process_uploaded_file(file):
    try:
        df = pd.read_csv(file.name)
        required = {"vendor_id", "vendor_name_id", "delivery_records", "issue_counts", "nps_values"}
        if not required.issubset(df.columns):
            return f"Missing required columns: {', '.join(required)}", None
        results = []
        for _, row in df.iterrows():
            res = score_vendor(row["vendor_id"], row["vendor_name_id"], row["delivery_records"], row["issue_counts"], row["nps_values"])
            if "error" not in res:
                results.append(res)
        if not results:
            return "No valid records found", None
        return "Batch processed", pd.DataFrame(results)[[
            "vendor_id", "vendor_name_id", "score", "timeliness_score",
            "issue_score", "feedback_score", "evaluation_date", "rationale"
        ]]
    except Exception as e:
        return f"Error processing file: {e}", None

# Gradio UI
with gr.Blocks(title="Vendor Performance App") as demo:
    gr.Markdown("## 📊 Vendor Performance Scoring Tool")

    with gr.Tabs():
        with gr.Tab("Single Vendor"):
            vendor_id = gr.Textbox(label="Vendor ID")
            vendor_name_id = gr.Textbox(label="Vendor Name")  # Updated label to only expect name
            delivery = gr.Slider(0, 100, label="Delivery %")
            issues = gr.Number(label="Issue Count", minimum=0)
            nps = gr.Slider(0, 100, label="NPS")

            status = gr.Textbox(label="Status", interactive=False)
            result_table = gr.Dataframe(headers=[
                "Vendor ID", "Vendor Name", "Score", "Timeliness",
                "Issues", "Feedback", "Date", "Rationale"
            ])

            submit = gr.Button("Submit")
            submit.click(
                fn=format_output,
                inputs=[vendor_id, vendor_name_id, delivery, issues, nps],
                outputs=[status, result_table]
            )

        with gr.Tab("Upload CSV"):
            file_upload = gr.File(label="Upload CSV (vendor_name_id should contain vendor names)", file_types=[".csv"])
            file_status = gr.Textbox(label="Upload Status")
            file_result = gr.Dataframe(headers=[
                "Vendor ID", "Vendor Name", "Score", "Timeliness",
                "Issues", "Feedback", "Date", "Rationale"
            ])

            file_upload.change(
                fn=process_uploaded_file,
                inputs=file_upload,
                outputs=[file_status, file_result]
            )

if __name__ == "__main__":
    import uvicorn
    demo.launch(server_name="0.0.0.0", server_port=7860)
    uvicorn.run(app, host="0.0.0.0", port=8000)