File size: 16,986 Bytes
6a477c5
8719087
6a477c5
 
 
369194d
 
71978cc
128cbd6
59fda72
6a477c5
4be2e38
6a477c5
8719087
6a477c5
540f4a3
6a477c5
4be2e38
8719087
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
6a477c5
a2f1a4d
369194d
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
6a477c5
 
 
4be2e38
59fda72
427c1b1
6a477c5
 
 
 
128cbd6
8719087
71978cc
369194d
 
 
427c1b1
369194d
128cbd6
369194d
128cbd6
369194d
128cbd6
369194d
128cbd6
 
 
 
 
369194d
 
128cbd6
369194d
128cbd6
 
369194d
128cbd6
369194d
128cbd6
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
369194d
 
128cbd6
 
6459fb3
369194d
 
 
 
 
 
 
6459fb3
369194d
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
128cbd6
 
369194d
 
 
427c1b1
128cbd6
 
427c1b1
59fda72
 
 
 
 
 
8719087
59fda72
 
 
 
 
 
6459fb3
 
 
59fda72
6459fb3
 
d1e630b
59fda72
 
 
128cbd6
 
59fda72
369194d
 
501d2d9
 
 
 
 
 
 
 
 
 
 
369194d
501d2d9
 
 
 
369194d
501d2d9
 
 
369194d
128cbd6
 
6459fb3
128cbd6
6459fb3
 
128cbd6
 
6459fb3
8719087
 
40bbbf4
 
 
 
8719087
40bbbf4
8719087
369194d
8719087
 
40bbbf4
 
369194d
 
 
 
8719087
6459fb3
369194d
 
 
 
 
6459fb3
369194d
128cbd6
369194d
 
128cbd6
 
369194d
 
 
 
 
 
 
 
 
 
 
 
128cbd6
369194d
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
40bbbf4
128cbd6
 
369194d
 
 
 
 
 
 
 
 
 
128cbd6
40bbbf4
6a477c5
 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
from flask import Flask, render_template, request, jsonify
from simple_salesforce import Salesforce
from dotenv import load_dotenv
import os
import logging
import uuid
from datetime import datetime


# Load environment variables
load_dotenv()

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

app = Flask(__name__, template_folder='templates', static_folder='static')

# Salesforce connection function
def get_salesforce_connection():
    try:
        sf = Salesforce(
            username=os.getenv('SFDC_USERNAME'),
            password=os.getenv('SFDC_PASSWORD'),
            security_token=os.getenv('SFDC_SECURITY_TOKEN'),
            domain=os.getenv('SFDC_DOMAIN', 'login')
        )
        logger.info("Successfully connected to Salesforce")
        return sf
    except Exception as e:
        logger.error(f"Error connecting to Salesforce: {e}")
        return None

# Initialize Salesforce connection
sf = get_salesforce_connection()

# Initialize OpenAI client
openai_api_key = os.getenv('OPENAI_API_KEY')
if not openai_api_key:
    logger.error("OPENAI_API_KEY not found in .env. ChatGPT functionality disabled.")
    client = None
else:
    try:
        client = OpenAI(api_key=openai_api_key)
        test_response = client.chat.completions.create(
            model="gpt-3.5-turbo",
            messages=[{"role": "user", "content": "Test API key"}]
        )
        logger.info("OpenAI API key validated successfully")
    except Exception as e:
        logger.error(f"Invalid OpenAI API key or connection issue: {e}")
        client = None

# Conversation storage
conversation_sessions = {}

def is_restaurant_related(query):
    keywords = ['use', 'uses', 'dish', 'recipe', 'ingredient', 'food', 'menu', 'vegetarian', 'non-vegetarian',
                'rice', 'chicken', 'pasta', 'veggie', 'mutton', 'lamb', 'beef', 'pork', 'fish', 'seafood',
                'ingredients', 'nutrition', 'nutritional', 'info', 'message', 'messages']
    return bool(query.strip() and any(keyword in query.lower() for keyword in keywords)) or any(item in query.lower() for item in ['mutton', 'rice', 'chicken'])

def get_chatgpt_response(prompt, session_id):
    if not client:
        logger.warning("No OpenAI client available, using mock ChatGPT response")
        if any(item in prompt.lower() for item in ['mutton', 'rice', 'chicken']):
            return f"{prompt.capitalize()} is great for curries or roasts in a restaurant!"
        return "I can help with food! Try 'uses of mutton' or 'ingredients for rice'."

    if session_id not in conversation_sessions:
        conversation_sessions[session_id] = [
            {"role": "system", "content": "You are a restaurant culinary assistant. Respond only to queries about ingredients, dishes, or recipes. Provide concise, friendly answers. For unclear queries, suggest: 'Try 'uses of mutton' or 'ingredients for rice'.'"}
        ]

    prompt = prompt.strip().lower()
    logger.info(f"Processing prompt: {prompt}")
    if not is_restaurant_related(prompt):
        logger.info(f"Off-topic or empty query: {prompt}")
        return "I can help with food! Try 'uses of mutton' or 'ingredients for rice'."

    intent = "uses"
    item = prompt
    if "what is the use of" in prompt or "uses of" in prompt:
        item = prompt.replace("what is the use of ", "").replace("uses of ", "").strip() or prompt
        prompt = f"Provide the culinary uses of '{item}' for a restaurant. Be concise and friendly. If unknown, say 'Great for many dishes!'"
    elif any(word in prompt for word in ['suggest', 'recipe', 'dish']):
        intent = "suggest"
        prompt = f"Suggest a restaurant dish based on: {prompt}. Include ingredients and be concise."
    elif any(word in prompt for word in ['ingredients', 'ingredient']):
        intent = "ingredients"
        item = prompt.replace("ingredients for ", "").replace("ingredient of ", "").strip() or prompt
        prompt = f"List common ingredients for a restaurant dish using '{item}'. Be concise and realistic."
    elif any(word in prompt for word in ['nutrition', 'nutritional', 'info']):
        intent = "nutrition"
        item = prompt.replace("nutrition of ", "").replace("nutritional info for ", "").strip() or prompt
        prompt = f"Provide a concise, approximate nutritional overview (calories, protein, fat, carbs) for a restaurant portion of '{item}'. Use general culinary knowledge and keep it friendly."
    elif any(item in prompt for item in ['mutton', 'rice', 'chicken', 'pasta', 'veggie', 'lamb', 'beef', 'pork', 'fish', 'seafood']):
        prompt = f"Provide the culinary uses of '{item}' for a restaurant. Be concise and friendly. If unknown, say 'Great for many dishes!'"
    else:
        logger.info(f"Unclear intent, defaulting to uses for: {prompt}")
        prompt = f"Provide the culinary uses of '{prompt}' for a restaurant. Be concise and friendly. If unknown, say 'Great for many dishes!'"

    conversation_sessions[session_id].append({"role": "user", "content": prompt})

    try:
        response = client.chat.completions.create(
            model="gpt-3.5-turbo",
            messages=conversation_sessions[session_id],
            max_tokens=150,
            timeout=10
        )
        reply = response.choices[0].message.content.strip()
        conversation_sessions[session_id].append({"role": "assistant", "content": reply})
        logger.info(f"ChatGPT response for '{prompt}': {reply}")
        return reply
    except Exception as e:
        logger.error(f"OpenAI API error: {e}")
        return f"Sorry, API failed. Mock response: {prompt.capitalize()} is great for curries or roasts!"

@app.route('/')
def index():
    return render_template('index.html')

@app.route('/get_menu_items', methods=['POST'])
def get_menu_items():
    global sf
    if not sf:
        sf = get_salesforce_connection()
        if not sf:
            logger.error("Salesforce connection failed after retry")
            return jsonify({"error": "Unable to connect to Salesforce"}), 500

    data = request.json
    dietary_preference = data.get('dietary_preference', 'both').lower()
    search_term = data.get('search_term', '').strip()
    try:
        items = []
        # Query Sector_Detail__c for dietary preferences
        if not search_term:
            soql_sector = "SELECT Name, Image_URL__c, Category__c, Description__c FROM Sector_Detail__c"
            if dietary_preference == 'vegetarian':
                soql_sector += " WHERE Category__c = 'Veg'"
            elif dietary_preference == 'non-vegetarian':
                soql_sector += " WHERE Category__c = 'Non-Veg'"
            soql_sector += " LIMIT 200"
            logger.info(f"Executing SOQL query for Sector_Detail__c: {soql_sector}")
            result_sector = sf.query(soql_sector)
            sector_items = [
                {
                    "name": record['Name'],
                    "image_url": record.get('Image_URL__c', ''),
                    "category": record.get('Category__c', ''),
                    "description": record.get('Description__c', 'No description available'),
                    "source": "Sector_Detail__c"
                }
                for record in result_sector['records'] if 'Name' in record
            ]
            items.extend(sector_items)
        
        # Query Menu_Item__c
        soql_menu = "SELECT Name, Description__c, Image1__c, Ingredientsinfo__c, NutritionalInfo__c, Price__c, Sector__c, Spice_Levels__c, Veg_NonVeg__c, Category__c, Dynamic_Dish__c FROM Menu_Item__c"
        if search_term:
            soql_menu += f" WHERE Name LIKE '%{search_term}%' OR Ingredientsinfo__c LIKE '%{search_term}%'"
        elif dietary_preference == 'vegetarian':
            soql_menu += " WHERE Veg_NonVeg__c = 'Vegetarian'"
        elif dietary_preference == 'non-vegetarian':
            soql_menu += " WHERE Veg_NonVeg__c = 'Non-Vegetarian'"
        soql_menu += " LIMIT 200"
        logger.info(f"Executing SOQL query for Menu_Item__c: {soql_menu}")
        result_menu = sf.query(soql_menu)
        menu_items = [
            {
                "name": record['Name'],
                "description": record.get('Description__c', 'No description available'),
                "image_url": record.get('Image1__c', ''),
                "ingredients": record.get('Ingredientsinfo__c', ''),
                "nutritional_info": record.get('NutritionalInfo__c', ''),
                "price": record.get('Price__c', 0.0),
                "sector": record.get('Sector__c', ''),
                "spice_levels": record.get('Spice_Levels__c', ''),
                "veg_nonveg": record.get('Veg_NonVeg__c', ''),
                "category": record.get('Category__c', ''),
                "dynamic_dish": record.get('Dynamic_Dish__c', False),
                "source": "Menu_Item__c"
            }
            for record in result_menu['records'] if 'Name' in record
        ]
        items.extend(menu_items)

        logger.info(f"Fetched {len(items)} items (Sector_Detail__c: {len([i for i in items if i['source'] == 'Sector_Detail__c'])}, Menu_Item__c: {len([i for i in items if i['source'] == 'Menu_Item__c'])}) for {dietary_preference or search_term}")
        return jsonify({"menu_items": items})
    except Exception as e:
        logger.error(f"Failed to fetch items: {str(e)}")
        return jsonify({"error": f"Failed to fetch items from Salesforce: {str(e)}"}), 500

@app.route('/get_sector_item_details', methods=['POST'])
def get_sector_item_details():
    global sf
    if not sf:
        sf = get_salesforce_connection()
        if not sf:
            return jsonify({"error": "Unable to connect to Salesforce"}), 500

    item_name = request.json.get('item_name', '').strip()
    if not item_name:
        return jsonify({"error": "Item name is required"}), 400

    try:
        soql = f"SELECT Name, Image_URL__c, Category__c, Description__c FROM Sector_Detail__c WHERE Name LIKE '%{item_name}%' LIMIT 1"
        logger.info(f"Executing SOQL query: {soql}")
        result = sf.query(soql)

        if result['totalSize'] == 0:
            return jsonify({"error": f"No item found matching '{item_name}' in Sector_Detail__c"}), 404

        record = result['records'][0]
        item_details = {
            "name": record.get('Name', ''),
            "image_url": record.get('Image_URL__c', 'https://via.placeholder.com/30'),
            "category": record.get('Category__c', ''),
            "description": record.get('Description__c', 'No description available'),
            "source": "Sector_Detail__c"
        }
        logger.info(f"Fetched details for '{item_name}' from Sector_Detail__c")
        return jsonify({"item_details": item_details})
    except Exception as e:
        logger.error(f"Failed to fetch item details from Sector_Detail__c: {str(e)}")
        return jsonify({"error": f"Failed to fetch item details from Salesforce: {str(e)}"}), 500

@app.route('/suggest_items', methods=['POST'])
def suggest_items():
    global sf
    if not sf:
        sf = get_salesforce_connection()
        if not sf:
            return jsonify({"error": "Unable to connect to Salesforce"}), 500

    search_term = request.json.get('search_term', '').strip()
    if not search_term:
        return jsonify({"error": "Search term is required"}), 400

    try:
        soql = f"SELECT Ingredient_Name__c, Image_URL__c FROM Ingredient_Object__c WHERE Ingredient_Name__c LIKE '%{search_term}%' LIMIT 10"
        logger.info(f"Executing SOQL query: {soql}")
        result = sf.query(soql)
        suggestions = [
            {"name": record['Ingredient_Name__c'], "image_url": record.get('Image_URL__c', '')}
            for record in result['records'] if 'Ingredient_Name__c' in record
        ]
        logger.info(f"Fetched {len(suggestions)} suggestions for '{search_term}'")
        return jsonify({"suggestions": suggestions})
    except Exception as e:
        logger.error(f"Failed to fetch suggestions: {str(e)}")
        return jsonify({"error": f"Failed to fetch suggestions: {str(e)}"}), 500

@app.route('/get_item_details', methods=['POST'])
def get_item_details():
    global sf
    if not sf:
        sf = get_salesforce_connection()
        if not sf:
            return jsonify({"error": "Unable to connect to Salesforce"}), 500

    item_name = request.json.get('item_name', '').strip()
    if not item_name:
        return jsonify({"error": "Item name is required"}), 400

    try:
        soql = f"SELECT Ingredient_Name__c, Image_URL__c FROM Ingredient_Object__c WHERE Ingredient_Name__c LIKE '%{item_name}%' LIMIT 1"
        logger.info(f"Executing SOQL query: {soql}")
        result = sf.query(soql)

        if result['totalSize'] == 0:
            return jsonify({"error": f"No item found matching '{item_name}' in Ingredient_Object__c"}), 404

        record = result['records'][0]
        item_details = {
            "name": record.get('Ingredient_Name__c', ''),
            "image_url": record.get('Image_URL__c', ''),
            "source": "Ingredient_Object__c"
        }
        logger.info(f"Fetched details for '{item_name}' from Ingredient_Object__c")
        return jsonify({"item_details": item_details})
    except Exception as e:
        logger.error(f"Failed to fetch item details: {str(e)}")
        return jsonify({"error": f"Failed to fetch item details: {str(e)}"}), 500

@app.route('/submit_items', methods=['POST'])
def submit_items():
    global sf
    if not sf:
        sf = get_salesforce_connection()
        if not sf:
            return jsonify({"error": "Unable to connect to Salesforce"}), 500

    items = request.json.get('items', [])
    custom_order_name = request.json.get('custom_order_name', '')
    if not items:
        return jsonify({"error": "No items to submit"}), 400

    try:
        ingredient_name = custom_order_name or f"Order_{datetime.now().strftime('%Y%m%d')}_{uuid.uuid4().hex[:8]}"
        item_names = ', '.join(item['name'] for item in items)
        description = f"Contains: {item_names}"

        for item in items:
            sf.Ingredient_Object__c.create({
                'Ingredient_Name__c': ingredient_name,
                'Category__c': item.get('category', ''),
                'Description__c': f"{item.get('description', 'No description')} - {description}",
                'Image_URL__c': item.get('image_url', ''),
                'Quantity__c': item.get('quantity', 1)
            })

        logger.info(f"Submitted {len(items)} items under {ingredient_name}")
        return jsonify({"success": f"Submitted {len(items)} items under {ingredient_name}", "ingredient_name": ingredient_name})
    except Exception as e:
        logger.error(f"Failed to submit items: {str(e)}")
        return jsonify({"error": f"Failed to submit items: {str(e)}"}), 500

@app.route('/get_item_info', methods=['POST'])
def get_item_info():
    global sf, client
    item_name = request.json.get('item_name', '').strip()
    if not item_name or not client:
        return jsonify({"error": "Item name required or OpenAI unavailable"}), 400

    try:
        soql = f"SELECT Name, Description__c FROM Sector_Detail__c WHERE Name LIKE '%{item_name}%' LIMIT 1"
        result = sf.query(soql)
        if result['totalSize'] == 0:
            return jsonify({"error": f"No item found matching '{item_name}' in Sector_Detail__c"}), 404

        record = result['records'][0]
        base_info = record.get('Description__c', 'No description available')

        prompt = f"Based on general culinary knowledge, provide a concise list of common ingredients and an approximate nutritional overview (calories, protein, fat, carbs) for a restaurant portion of '{item_name}'. Use realistic values and keep it friendly."
        response = client.chat.completions.create(
            model="gpt-3.5-turbo",
            messages=[{"role": "user", "content": prompt}],
            max_tokens=150,
            timeout=10
        )
        ai_response = response.choices[0].message.content.strip()

        item_info = {
            "name": record['Name'],
            "description": base_info,
            "details": ai_response
        }
        logger.info(f"Generated info for '{item_name}'")
        return jsonify({"item_info": item_info})
    except Exception as e:
        logger.error(f"Failed to get item info: {str(e)}")
        return jsonify({"error": f"Failed to get item info: {str(e)}"}), 500

@app.route('/chat', methods=['POST'])
def chat():
    user_message = request.json.get('message', '').strip()
    session_id = request.json.get('session_id', 'default')
    if not user_message:
        return jsonify({"error": "No message provided"}), 400

    response = get_chatgpt_response(user_message, session_id)
    logger.info(f"Chat response sent: {response}")
    return jsonify({"response": response})

if __name__ == '__main__':
    app.run(debug=True, host='0.0.0.0', port=7860)