controller/imports.py

from io import BytesIO
from dotenv import load_dotenv
import os
from gamification.objects import SimpleIndividualUserLevel
from controller.utils import *
from fastapi import FastAPI, File, HTTPException, Header, UploadFile,status
from controller.tokenManagement import *
from controller.jwtcoding import *
from fastapi.responses import JSONResponse
import docx
import fitz
from gamification.routes import gamification
from controller.scraper import scrapeCourse
import asyncio
from google import genai 
from typing import Optional,List
from pydantic import BaseModel
import re
from bson.json_util import dumps
import threading
import concurrent.futures
from gamification.pointLogic import get_all_simple_points_func,get_dream_job
from pydantic import BaseModel
from datetime import datetime
from bson import ObjectId
import os 
import re
from urllib.parse import urlparse

from concurrent.futures import ThreadPoolExecutor
executor = ThreadPoolExecutor(max_workers=5)


load_dotenv()

CX = os.getenv("SEARCH_ENGINE_ID")
API_KEY = os.getenv("GOOGLE_API_KEY")
PINECONE_API_KEY=os.getenv("PINECONE_API_KEY")
GEMINI_API_KEY=os.getenv("GEMINI_API_KEY")
MONGO_URI=os.getenv("MONGO_URI")

class UserBody(BaseModel):
    firstName: Optional[str] = None
    lastName: Optional[str] = None
    email:str
    password:str
    
class AiAnalysis(BaseModel):
    query:str
    
class Token(BaseModel):
    refreshToken:str


class RecommendedCourse(BaseModel):
    courseTitle:Optional[str]=None
    courseLink:Optional[str]=None
    duration:Optional[str]=None
    courseLevel:Optional[str]=None
    interimRoleBenefit:Optional[str]=None
    dreamRoleBenefit:Optional[str]=None
    courseDescription:Optional[str]=None
    courseProvider:Optional[str]=None
class UserCourse(BaseModel):
    employmentStatus:str
    interimRole:bool
    interimRoleOptions:Optional[List[str]]=None
    dreamRole:str
    motivation:str
    learningPreference:str
    timeCommitmentPerDay:str
    challenges:list
    timeframeToAchieveDreamRole:str
    recommendedCourses: Optional[List[RecommendedCourse]]=None
    
class LeaderBoardRanking(BaseModel):
    userId:str
    firstName:str
    lastName:str
    totalpoints:float
    lastUpdated:datetime
    careerPath:str
    class Config:
        json_encoder ={
        ObjectId:str
        }
    
    

class CourseRecommendation(BaseModel):
    courseName: str
    completionTime: str






def extract_provider(url):
    # Parse the URL
    parsed_url = urlparse(url)
    
    # Extract domain and split it to get the main part
    domain = parsed_url.netloc.split('.')[1]
    
    # Extract course name
    match = re.search(r'/course/([^/]+)/', url)
    course_name = match.group(1) if match else "Not found"
    
    return domain

def get_course_func(query):
# Example search query
    results = google_search(query, API_KEY, CX)
    content=[]
   
    if results:
        for item in results.get('items', []):
            title = item.get('title')
            link = item.get('link')
            snippet = item.get('snippet')
            provider = extract_provider(link)

            content_structure={}
            content_structure["courseTitle"]=title
            content_structure["courseLink"]=link
            content_structure["courseSnippet"]= snippet
            content_structure["scrapedCourseDetails"]= scrapeCourse(url=link)
            content.append(content_structure)

    return content
            

def extract_course_info(text: str) -> CourseRecommendation:
    # Example regex patterns – adjust these as needed based on the response format.
    course_pattern =r'"coursename":\s*"([^"]+)"'
    time_pattern = r"(\d+\s*-\s*\d+\s*months)"

    course_match = re.search(course_pattern, text)
    time_match = re.search(time_pattern, text)

    coursename = course_match.group(1).strip() if course_match else "Unknown"
    completiontime = time_match.group(0).strip() if time_match else "Unknown"

    return CourseRecommendation(courseName=coursename, completionTime=completiontime)