0

.env

@@ -1,4 +1 @@
-GEMINI_API_KEY=AIzaSyCtEVix5c3pv3wtt7JLUA0CWpmOCt2gBMw
-TELEGRAM_BOT_TOKEN=7868898974:AAH2p7sBkj0TH4sD__giOmUt-2ZXn7sg0_c
-TELEGRAM_CHAT_ID=5397241102
-# WEBHOOK_URL=https://your-domain.com  # Replace with your actual domain
+GEMINI_API_KEY=AIzaSyCtEVix5c3pv3wtt7JLUA0CWpmOCt2gBMw

app.py

@@ -1,18 +1,9 @@
-from flask import Flask, request
+from flask import Flask, request, render_template
 import google.generativeai as genai
 import base64
 import os
 from dotenv import load_dotenv
-import asyncio
-from datetime import datetime
-import re
-from aiogram import Bot, Dispatcher, types
-from aiogram.types import InputFile
-from aiogram.filters import Command, CommandStart
-from aiogram import F
-
-# Load environment variables
-load_dotenv()
+from werkzeug.utils import secure_filename
 
 # Initialize Flask app
 UPLOAD_FOLDER = '/tmp/uploads'
@@ -23,190 +14,83 @@ app.config['UPLOAD_FOLDER'] = UPLOAD_FOLDER
 genai.configure(api_key=os.getenv('GEMINI_API_KEY'))
 model = genai.GenerativeModel("gemini-1.5-flash")
 
-# Telegram Configuration
-TELEGRAM_BOT_TOKEN = os.getenv('TELEGRAM_BOT_TOKEN')
-WEBHOOK_URL = os.getenv('WEBHOOK_URL')
-bot = Bot(token=TELEGRAM_BOT_TOKEN)
-dp = Dispatcher()
-
-def extract_expiry_date(gemini_output):
-    """Extract expiry date from Gemini's output."""
-    date_pattern = r'(\d{1,2}[-/]\d{1,2}[-/]\d{2,4}|\d{1,2}\s+(?:January|February|March|April|May|June|July|August|September|October|November|December)\s+\d{2,4})'
-    dates = re.findall(date_pattern, gemini_output, re.IGNORECASE)
-    
-    if dates:
-        return dates[0]
-    return None
-
-async def process_certificate(image_path, cert_name):
-    """Process a single certificate."""
+def process_certificate(image_path, cert_name):
+    """Process a single certificate and generate a response in structured HTML."""
     with open(image_path, "rb") as image_file:
         encoded_image = base64.b64encode(image_file.read()).decode("utf-8")
 
     prompt = (
-        f"""Note: The current date is 12/12/2024 (12 December 2024). Process the following certificate:
+        """Note: The current date is 12/12/2024 (12 December 2024). Process the following certificate:
         - {cert_name}: (image attached)
-        
-        Instructions as provided...
-        """
+
+        For the certificate:
+        1. Check the expiry date on the certificate. Use the current date (12 December 2024) as the reference point:
+           - If the expiry date is earlier than the current date (past date), mark the certificate as Invalid❌.
+           - If the expiry date is later than the current date (future date), mark the certificate as Valid✅.
+           - If no expiry date is found but there are signs of validity (e.g., government seals, authorized signatures, or proper right marks), mark the certificate as Valid✅.
+
+        2. If neither the expiry date nor other validity signs are present, use semantic analysis of the certificate's content to determine its status:
+           - Mark the certificate as Valid✅ if the content supports its authenticity (e.g., trustworthy terms, verified names, or credible organizations).
+           - Mark the certificate as Invalid❌ if the content lacks any evidence of validity.
+
+        3. Structure the results in a clear and properly formatted table with the following columns:
+           - Field: Field extracted from the certificate.
+           - Value: The corresponding value.
+
+        4. Add a section indicating the certificate's overall validity status (Valid✅ or Invalid❌).
+
+        Return the entire result strictly within the '''html opening and '''html closing tags.
+        Ensure compatibility with rendering on a webpage.
+        """.format(cert_name=cert_name)
     )
 
     response = model.generate_content([
         {'mime_type': 'image/jpeg', 'data': encoded_image}, prompt
     ])
 
-    expiry_date = extract_expiry_date(response.text)
-    return response.text, expiry_date
-
-@dp.message(CommandStart())
-async def send_welcome(message: types.Message):
-    """Handle the /start command."""
-    welcome_text = (
-        "👋 Welcome to the Certificate Validation Bot!\n\n"
-        "Send me a photo or document of your certificate, and I'll:\n"
-        "✅ Process the certificate\n"
-        "📅 Extract the expiry date\n"
-        "⚠️ Alert you if it's expiring soon\n\n"
-        "Just send me your certificate as a photo or document!"
-    )
-    await message.reply(welcome_text)
+    return response.text
 
-@dp.message(Command('help'))
-async def send_help(message: types.Message):
-    """Handle the /help command."""
-    help_text = (
-        "🤖 Certificate Validation Bot Help\n\n"
-        "Commands:\n"
-        "/start - Start the bot\n"
-        "/help - Show this help message\n\n"
-        "To validate a certificate:\n"
-        "1. Send the certificate as a photo or document\n"
-        "2. Wait for the processing (usually takes a few seconds)\n"
-        "3. Receive the validation results and expiry alerts\n\n"
-        "The bot will automatically alert you if your certificate is expiring within 30 days."
-    )
-    await message.reply(help_text)
-
-@dp.message(F.content_type.in_({'photo', 'document'}))
-async def handle_file(message: types.Message):
-    """Handle certificate upload via Telegram."""
-    try:
-        # Send processing message
-        processing_msg = await message.reply("🔄 Processing your certificate...")
+@app.route("/", methods=["GET", "POST"])
+def home():
+    if request.method == "POST":
+        cert_name = "Affiliation Certificate"
         
-        # Save the file
-        upload_dir = app.config['UPLOAD_FOLDER']
-        os.makedirs(upload_dir, exist_ok=True)
+        # Check if the post request has the file part
+        if 'certificate' not in request.files:
+            return render_template("index.html", error="No file part in the request")
         
-        if message.photo:
-            # Handle photo
-            photo = message.photo[-1]  # Get the largest photo size
-            file_path = os.path.join(upload_dir, f"{photo.file_id}.jpg")
-            await photo.download(destination_file=file_path)
-            cert_name = "Photo Certificate"
-        else:
-            # Handle document
-            document = message.document
-            file_path = os.path.join(upload_dir, document.file_name)
-            await document.download(destination_file=file_path)
-            cert_name = document.file_name
-
-        # Process the certificate
-        try:
-            result_text, expiry_date = await process_certificate(file_path, cert_name)
+        file = request.files['certificate']
+        
+        # If user does not select file, browser also submits an empty part without filename
+        if file.filename == '':
+            return render_template("index.html", error="No file selected")
             
-            # Format the response message
-            response_message = "📄 *Certificate Analysis:*\n\n"
-            response_message += result_text
-
-            # Send the analysis result
-            await bot.send_message(
-                chat_id=message.chat.id,
-                text=response_message,
-                parse_mode='Markdown'
-            )
-
-            # Handle expiry date if found
-            if expiry_date:
-                try:
-                    # Try different date formats
-                    for date_format in ['%d/%m/%Y', '%d-%m-%Y', '%d %B %Y']:
-                        try:
-                            expiry_date_obj = datetime.strptime(expiry_date, date_format)
-                            break
-                        except ValueError:
-                            continue
-                    
-                    current_date = datetime.now()
-                    days_until_expiry = (expiry_date_obj - current_date).days
-
-                    # Prepare alert message based on expiry status
-                    if days_until_expiry <= 30:
-                        alert_message = "⚠️ *Certificate Expiry Alert*\n\n"
-                        alert_message += f"*Certificate:* {cert_name}\n"
-                        
-                        if days_until_expiry < 0:
-                            alert_message += f"*Status:* 🚫 EXPIRED ({abs(days_until_expiry)} days ago)"
-                        else:
-                            alert_message += f"*Status:* ⚠️ Expiring in {days_until_expiry} days"
-                        
-                        # Add recommendation
-                        if days_until_expiry < 0:
-                            alert_message += "\n\n*Recommendation:* Immediate renewal required!"
-                        else:
-                            alert_message += "\n\n*Recommendation:* Please plan for renewal soon."
-
-                        await bot.send_message(
-                            chat_id=message.chat.id,
-                            text=alert_message,
-                            parse_mode='Markdown'
-                        )
-                except Exception as date_error:
-                    await bot.send_message(
-                        chat_id=message.chat.id,
-                        text=f"⚠️ Could not process expiry date: {str(date_error)}"
-                    )
-
-        except Exception as proc_error:
-            await bot.send_message(
-                chat_id=message.chat.id,
-                text=f"❌ Error processing certificate: {str(proc_error)}"
-            )
-
-        # Clean up - delete the file after processing
-        if os.path.exists(file_path):
-            os.remove(file_path)
-
-    except Exception as e:
-        await bot.send_message(
-            chat_id=message.chat.id,
-            text=f"❌ Error handling file: {str(e)}"
-        )
-    finally:
-        # Delete the processing message
+        # Check if the file type is allowed (you may want to add more types)
+        allowed_extensions = {'png', 'jpg', 'jpeg', 'pdf'}
+        if not file.filename.lower().endswith(tuple(allowed_extensions)):
+            return render_template("index.html", error="Invalid file type. Please upload an image or PDF file.")
+        
         try:
-            await processing_msg.delete()
-        except:
-            pass
-
-# Add Flask route for Telegram webhook
-@app.route(f'/{TELEGRAM_BOT_TOKEN}', methods=['POST'])
-async def webhook():
-    """Handle incoming updates from Telegram webhook."""
-    if request.headers.get('content-type') == 'application/json':
-        update = types.Update(**request.json)
-        await dp.process_update(update)
-        return '', 200
-    return '', 403
-
-# Initialize webhook on startup
-@app.before_first_request
-def setup_webhook():
-    """Set up the Telegram webhook when the Flask app starts."""
-    asyncio.run(bot.set_webhook(f"{WEBHOOK_URL}/{TELEGRAM_BOT_TOKEN}"))
+            # Create uploads directory if it doesn't exist
+            upload_dir = app.config['UPLOAD_FOLDER']
+            os.makedirs(upload_dir, exist_ok=True)
+            
+            # Secure the filename and save the file
+            filename = secure_filename(file.filename)
+            image_path = os.path.join(upload_dir, filename)
+            file.save(image_path)
+            
+            # Process the certificate
+            try:
+                gemini_output = process_certificate(image_path, cert_name)
+                return render_template("index.html", gemini_output=gemini_output)
+            except Exception as e:
+                return render_template("index.html", error=f"Error processing certificate: {str(e)}")
+                
+        except Exception as e:
+            return render_template("index.html", error=f"Error saving file: {str(e)}")
+
+    return render_template("index.html")
 
 if __name__ == "__main__":
-    # Create upload directory if it doesn't exist
-    os.makedirs(app.config['UPLOAD_FOLDER'], exist_ok=True)
-    # Run Flask app
-    app.run(host='0.0.0.0', port=7860)
+    app.run(host='0.0.0.0', port=7860)