Create app.py

app.py

@@ -0,0 +1,712 @@
+import io
+import os
+import openai
+import re
+import sqlite3
+import base64
+import calendar
+import json
+import time
+import uuid
+from reportlab.platypus import SimpleDocTemplate, Paragraph
+from reportlab.lib.styles import getSampleStyleSheet
+import streamlit as st
+from streamlit_js_eval import streamlit_js_eval
+from langchain.embeddings.openai import OpenAIEmbeddings
+from langchain.vectorstores.azuresearch import AzureSearch
+from azure.storage.blob import BlobServiceClient
+from azure.cosmos import CosmosClient, exceptions
+from PyPDF2 import PdfReader
+import openai
+import sendgrid
+from sendgrid.helpers.mail import Mail, Attachment, FileContent, FileName, FileType, Disposition
+from twilio.rest import Client
+import ssl
+ssl._create_default_https_context = ssl._create_unverified_context
+
+openai.api_key = os.getenv("OPENAI_API_KEY")
+openai.api_base = "https://tensora-oai.openai.azure.com/"
+openai.api_type = "azure"
+openai.api_version = "2023-05-15"
+
+connection_string = os.getenv("CONNECTION")
+blob_service_client = BlobServiceClient.from_connection_string(connection_string)
+
+def upload_blob(pdf_name, json_data, pdf_data_jobdescription,pdf_data_cvs, pre_generated_bool, custom_questions):
+    try:
+        container_name = "jobdescriptions"
+        # json_blob_name = f"{pdf_name}_jsondata.json"
+        pdf_blob_name_jobdescription = f"{pdf_name}.pdf"
+
+        container_client = blob_service_client.get_container_client(container_name)
+
+        # json_blob_client = container_client.get_blob_client(json_blob_name)
+        # json_blob_client.upload_blob(json_data.encode('utf-8'), overwrite=True)
+
+        pdf_blob_client = container_client.get_blob_client(pdf_blob_name_jobdescription)
+        pdf_blob_client.upload_blob(pdf_data_jobdescription, overwrite=True)
+
+        upload_job_db_item(pdf_name,len(pdf_data_cvs),json.loads(json_data),pre_generated_bool, custom_questions)
+        if pre_generated_bool:
+            for i,question in enumerate(custom_questions):
+                question_nr_for_id = i+1
+                question_id = pdf_name + "-question-nr-" + str(question_nr_for_id)+str(calendar.timegm(time.gmtime()))
+                upload_question_db_item(question_id, pdf_name, question,st.session_state["job_string"])
+        links = []
+        names = []
+        for i,cv in enumerate(pdf_data_cvs):
+
+            cv_nr_for_id = i+1
+            cv_session_state_string = "cv-"+str(cv_nr_for_id)
+            session_state_name = st.session_state["final_candidates"][i][0].metadata["name"]
+            names.append(session_state_name)
+            cv_id = pdf_name + "-cv-nr-" + str(cv_nr_for_id)+str(calendar.timegm(time.gmtime()))
+            upload_db_item(session_state_name, json.loads(json_data), pdf_name, cv_id)
+            pdf_blob_name_cv = f"{cv_id}.pdf"
+            pdf_blob_client = container_client.get_blob_client(pdf_blob_name_cv)
+            pdf_blob_client.upload_blob(pdf_data_cvs[i], overwrite=True)
+            links.append("https://tensora.ai/workgenius/cv-evaluation2/?job="+cv_id)
+
+        return links
+    except Exception as e:
+        print(f"Fehler beim Hochladen der Daten: {str(e)}")
+        return []
+
+def upload_job_db_item(id, number_of_applicants, data, pre_generated_bool, custom_questions):
+    endpoint = "https://wg-candidate-data.documents.azure.com:443/"
+    key = os.getenv("CONNECTION_DB")
+    client = CosmosClient(endpoint, key)
+    database = client.get_database_client("ToDoList")
+    container = database.get_container_client("JobData")
+    job_item = {
+        "id": id,
+        'partitionKey' : 'wg-job-data-v1',
+        "title": data["title"],
+        "number_of_applicants": number_of_applicants,
+        "every_interview_conducted": False,
+        "evaluation_email": data["email"],
+        "question_one": data["question_one"],
+        "question_two": data["question_two"],
+        "question_three": data["question_three"],
+        "pre_generated": pre_generated_bool,
+        "custom_questions": custom_questions
+    }
+    try:
+        # Fügen Sie das Element in den Container ein
+        container.create_item(body=job_item)
+        print("Eintrag erfolgreich in die Cosmos DB eingefügt. Container: Job Data")
+    except exceptions.CosmosHttpResponseError as e:
+        print(f"Fehler beim Schreiben in die Cosmos DB: {str(e)}")
+    except Exception as e:
+        print(f"Allgemeiner Fehler: {str(e)}")
+
+def upload_db_item(name, data, job_description_id, cv_id):
+
+    endpoint = "https://wg-candidate-data.documents.azure.com:443/"
+    key = os.getenv("CONNECTION_DB")
+    client = CosmosClient(endpoint, key)
+    database = client.get_database_client("ToDoList")
+    container = database.get_container_client("Items")
+    candidate_item = {
+        "id": cv_id,
+        'partitionKey' : 'wg-candidate-data-v1',
+        "name": name,
+        "title": data["title"],
+        "interview_conducted": False,
+        "ai_summary": "",
+        "evaluation_email": data["email"],
+        "question_one": data["question_one"],
+        "question_two": data["question_two"],
+        "question_three": data["question_three"],
+        "job_description_id": job_description_id,
+    }
+
+    try:
+        # Fügen Sie das Element in den Container ein
+        container.create_item(body=candidate_item)
+        print("Eintrag erfolgreich in die Cosmos DB eingefügt. Container: Items(candidate Data)")
+    except exceptions.CosmosHttpResponseError as e:
+        print(f"Fehler beim Schreiben in die Cosmos DB: {str(e)}")
+    except Exception as e:
+        print(f"Allgemeiner Fehler: {str(e)}")
+
+def upload_question_db_item(id, job_id, question, job_content):
+    endpoint = "https://wg-candidate-data.documents.azure.com:443/"
+    key = os.getenv("CONNECTION_DB")
+    client = CosmosClient(endpoint, key)
+    database = client.get_database_client("ToDoList")
+    container = database.get_container_client("Questions")
+    question_item = {
+        "id": id,
+        "partitionKey" : "wg-question-data-v1",
+        "job_id": job_id,
+        "question_content": question,
+        "job_description": job_content,
+    }
+    try:
+        # Fügen Sie das Element in den Container ein
+        container.create_item(body=question_item)
+        print("Eintrag erfolgreich in die Cosmos DB eingefügt. Container: Questions(Question Data)")
+    except exceptions.CosmosHttpResponseError as e:
+        print(f"Fehler beim Schreiben in die Cosmos DB: {str(e)}")
+    except Exception as e:
+        print(f"Allgemeiner Fehler: {str(e)}")
+
+st.markdown(
+"""
+<style>
+    [data-testid=column]{
+        text-align: center;
+        display: flex;
+        align-items: center;
+        justify-content: center;
+    }
+    h3{
+        text-align: left;
+    }
+</style>
+""",
+    unsafe_allow_html=True,
+)
+
+with open("sys_prompt_frontend.txt") as f:
+    sys_prompt = f.read()
+with open("sys_prompt_job_optimization.txt") as j:
+    sys_prompt_optimization = j.read()
+
+def adjust_numbering(lst):
+    return [f"{i + 1}. {item.split('. ', 1)[1]}" for i, item in enumerate(lst)]
+
+def generate_candidate_mail(candidate, chat_link)-> str:
+    candidate_first_name = candidate[0].metadata["name"].split(" ")[0]
+    prompt = f"You are a professional recruiter who has selected a suitable candidate on the basis of a job description. Your task is to write two to three sentences about the applicant and explain why we think they are suitable for the job. The text will then be used in an e-mail to the applicant, so please address it to them. Please start the e-mail with 'Dear {candidate_first_name}'. I'll write the end of the mail myself."
+    try:
+        res = openai.ChatCompletion.create(
+            engine="gpt-4",
+            temperature=0.2,
+            messages=[
+                {
+                    "role": "system",
+                    "content": prompt,
+                },
+                {"role": "system", "content": "Job description: "+st.session_state["job_string"]+"; Resume: "+candidate[0].page_content}
+            ],
+        )
+        # print(res.choices[0]["message"]["content"])
+    except Exception as e:
+        # Iterativ die Anfrage wiederholen und 200 Chars von hinten vom Resume weglassen
+        max_retries = 5
+        retries = 0
+        while retries < max_retries:
+            try:
+                # Reduziere die Länge des Resume um 200 Chars von hinten
+                candidate[0].page_content = candidate[0].page_content[:-200]
+
+                # Neue Anfrage senden
+                res = openai.ChatCompletion.create(
+                    engine="gpt-4",
+                    temperature=0.2,
+                    messages=[
+                        {
+                            "role": "system",
+                            "content": prompt,
+                        },
+                        {"role": "system", "content": "Job description: " + st.session_state["job_string"] + "; Resume: " + candidate[0].page_content}
+                    ],
+                )
+                # print(res.choices[0]["message"]["content"])
+
+                # Wenn die Anfrage erfolgreich ist, den Schleifen-Iterator beenden
+                break
+
+            except Exception as e:
+                # Bei erneuter Ausnahme die Schleife fortsetzen
+                retries += 1
+                if retries == max_retries:
+                    # Falls die maximale Anzahl von Wiederholungen erreicht ist, handle die Ausnahme entsprechend
+                    print("Max retries reached. Unable to get a valid response.")
+                    return "The CV was too long to generate a Mail"
+                    # Hier kannst du zusätzlichen Code für den Fall implementieren, dass die maximale Anzahl von Wiederholungen erreicht wurde.
+
+            # Optional: Füge eine Wartezeit zwischen den Anfragen hinzu, um API-Beschränkungen zu respektieren
+            time.sleep(1)
+        
+    output_string = f"""{res.choices[0]["message"]["content"]}
+
+We have added the job description to the mail attachment. 
+If you are interested in the position, please click on the following link, answer a few questions from our chatbot for about 10-15 minutes and we will get back to you.
+
+Link to the interview chatbot: {chat_link}
+
+Sincerely,
+WorkGenius
+"""
+    print("Mail generated")
+    return output_string
+
+def generate_job_bullets(job)->str:
+    prompt = "You are a professional recruiter whose task is to summarize the provided job description in the most important 5 key points. The key points should have a maximum of 8 words. The only thing you should return are the bullet points."
+    try:
+        res = openai.ChatCompletion.create(
+            engine="gpt-4",
+            temperature=0.2,
+            messages=[
+                {
+                    "role": "system",
+                    "content": prompt,
+                },
+                {"role": "system", "content": "Job description: "+job}
+            ],
+        )
+        # print(res.choices[0]["message"]["content"])
+        output_string = f"""{res.choices[0]["message"]["content"]}"""
+        # print(output_string)
+        return output_string
+    except Exception as e:
+        print(f"Fehler beim generieren der Bullets: {str(e)}")
+
+def check_keywords_in_content(database_path, table_name, input_id, keywords):
+    # Verbindung zur Datenbank herstellen
+    conn = sqlite3.connect(database_path)
+    cursor = conn.cursor()
+
+    # SQL-Abfrage, um die Zeile mit der angegebenen ID abzurufen
+    cursor.execute(f'SELECT * FROM {table_name} WHERE id = ?', (input_id,))
+    
+    # Ergebnis abrufen
+    row = cursor.fetchone()
+
+    # Wenn die Zeile nicht gefunden wurde, False zurückgeben
+    if not row:
+        conn.close()
+        print("ID not found")
+        return False
+
+    # Überprüfen, ob die Keywords in der Spalte content enthalten sind (case-insensitive)
+    content = row[1].lower()  # Annahme: content ist die zweite Spalte, und wir wandeln ihn in Kleinbuchstaben um
+    keywords_lower = [keyword.lower() for keyword in keywords]
+    
+    contains_keywords = all(keyword in content for keyword in keywords_lower)
+
+    # Verbindung schließen
+    conn.close()
+
+    return contains_keywords
+
+def load_candidates(fillup):
+    with st.spinner("Load the candidates, this may take a moment..."):
+        # print(st.session_state["job_string"])
+        filter_string = ""
+        query_string = "The following keywords must be included: " + text_area_params + " " + st.session_state["job_string"]
+        checked_candidates = []
+        db_path = 'cvdb.db'
+        table_name = 'files'
+        candidates_per_search = 100
+        target_candidates_count = 10
+        current_offset = 0
+
+        if st.session_state["screened"]:
+            filter_string = "amount_screenings gt 0 "
+        if st.session_state["handed"]:
+            if len(filter_string) > 0:
+                filter_string += "and amount_handoffs gt 0 "
+            else:
+                filter_string += "amount_handoffs gt 0 "
+        if st.session_state["placed"]:
+            if len(filter_string) > 0:
+                filter_string += "and amount_placed gt 0"
+            else:
+                filter_string += "amount_placed gt 0"
+        # print(filter_string)
+        if not fillup:
+            while len(checked_candidates) < target_candidates_count:
+                # Führe eine similarity search durch und erhalte 100 Kandidaten
+                if st.session_state["search_type"]:
+                    print("hybrid")
+                    # raw_candidates = st.session_state["db"].hybrid_search(query_string, k=candidates_per_search+current_offset, filters=filter_string)
+                    raw_candidates = st.session_state["db"].hybrid_search_with_score(query_string, k=candidates_per_search+current_offset, filters=filter_string)
+                else:
+                    print("similarity")
+                    # raw_candidates = st.session_state["db"].similarity_search(query_string, k=candidates_per_search+current_offset, filters=filter_string)
+                    raw_candidates = st.session_state["db"].similarity_search_with_relevance_scores(query_string, k=candidates_per_search+current_offset, filters=filter_string)
+
+                for candidate in raw_candidates[current_offset:]:
+                    candidates_id = candidate[0].metadata["source"].split("/")[-1]
+                    keyword_bool = check_keywords_in_content(db_path, table_name, candidates_id, text_area_params.split(','))
+                    
+                    if keyword_bool:
+                        checked_candidates.append(candidate)
+
+                        # Überprüfe, ob die Zielanzahl erreicht wurde und breche die Schleife ab, wenn ja
+                        if len(checked_candidates) >= target_candidates_count:
+                            break
+
+                current_offset += candidates_per_search
+                if current_offset == 600:
+                    break
+            # Setze die Ergebnisse in der Session State Variable
+            st.session_state["docs_res"] = checked_candidates
+            st.session_state["candidate_offset"] = current_offset
+            if len(checked_candidates) == 0:
+                st.error("No candidates can be found with these keywords. Please adjust the keywords and try again.", icon="🚨")
+        else:
+            # Setze die Zielanzahl auf 10
+            target_candidates_count = 10
+
+            current_offset = st.session_state["candidate_offset"]
+            
+            # Solange die Anzahl der überprüften Kandidaten kleiner als die Zielanzahl ist
+            while len(st.session_state["docs_res"]) < target_candidates_count:
+                # Führe eine similarity search durch und erhalte 100 Kandidaten
+                if st.session_state["search_type"]:
+                    print("hybrid")
+                    # raw_candidates = st.session_state["db"].hybrid_search(query_string, k=candidates_per_search+current_offset, filters=filter_string)
+                    raw_candidates = st.session_state["db"].hybrid_search_with_score(query_string, k=candidates_per_search+current_offset, filters=filter_string)
+                else:
+                    print("similarity")
+                    # raw_candidates = st.session_state["db"].similarity_search(query_string, k=candidates_per_search+current_offset, filters=filter_string)
+                    raw_candidates = st.session_state["db"].similarity_search_with_relevance_scores(query_string, k=candidates_per_search+current_offset, filters=filter_string)
+                temp_offset_add = 0 
+                for candidate in raw_candidates[current_offset:]:
+                    candidates_id = candidate[0].metadata["source"].split("/")[-1]
+                    keyword_bool = check_keywords_in_content(db_path, table_name, candidates_id, text_area_params.split(','))
+
+                    if keyword_bool:
+                        st.session_state["docs_res"].append(candidate)
+                        temp_offset_add += 1
+                        # Überprüfe, ob die Zielanzahl erreicht wurde und breche die Schleife ab, wenn ja
+                        if len(st.session_state["docs_res"]) >= target_candidates_count:
+                            st.session_state["candidate_offset"] = current_offset+temp_offset_add
+                            break
+
+                current_offset += candidates_per_search
+                if current_offset == 900:
+                    break
+
+            # Wenn die Liste immer noch leer ist, zeige eine Fehlermeldung an
+            if len(st.session_state["docs_res"]) == 0:
+                st.warning("No more candidates can be found.", icon="🔥")
+
+if "similarity_search_string" not in st.session_state:
+    st.session_state["similarity_search_string"] = None
+if "job_string" not in st.session_state:
+    st.session_state["job_string"] = None
+if "docs_res" not in st.session_state:
+    st.session_state["docs_res"] = None
+if "final_candidates" not in st.session_state:
+    st.session_state["final_candidates"] = None
+if "final_question_string" not in st.session_state:
+    st.session_state["final_question_string"] = []
+if "ai_questions" not in st.session_state:
+    st.session_state["ai_questions"] = None
+if "raw_job" not in st.session_state:
+    st.session_state["raw_job"] = None
+if "optimized_job" not in st.session_state:
+    st.session_state["optimized_job"] = None
+if "candidate_offset" not in st.session_state:
+    st.session_state["candidate_offset"] = 0
+if "db" not in st.session_state:
+    embedder = OpenAIEmbeddings(deployment="text-embedding-ada-002", chunk_size=1)
+    embedding_function = embedder.embed_query
+
+    db = AzureSearch(
+        index_name="wg-cvs-data",
+        azure_search_endpoint=os.environ.get("AZURE_SEARCH_ENDPOINT"),
+        azure_search_key=os.environ.get("AZURE_SEARCH_KEY"),
+        embedding_function=embedding_function,
+        # fields=fields
+    )
+    st.session_state["db"] = db
+
+
+col1, col2 = st.columns([2, 1])
+
+col1.title("Candidate Search")
+col2.image("https://www.workgenius.com/wp-content/uploads/2023/03/WorkGenius_navy-1.svg")
+
+st.write("Please upload the job description for which you would like candidates to be proposed.")
+col_file, col_clear = st.columns([6,1])
+
+with col_file:
+    uploaded_file_jobdescription = st.file_uploader("Upload the job description:", type=["pdf"], key="job")
+with col_clear:
+    if st.button("Clear", use_container_width=True):
+        streamlit_js_eval(js_expressions="parent.window.location.reload()")
+
+if st.session_state["job"]:
+    if not st.session_state["job_string"]:
+        if not st.session_state["optimized_job"]:
+            with st.spinner("Optimizing the job description. This may take a moment..."):
+                pdf_data_jobdescription = st.session_state["job"].read()
+                pdf_data_jobdescription_string = ""
+                pdf_reader_job = PdfReader(io.BytesIO(pdf_data_jobdescription))
+                for page_num in range(len(pdf_reader_job.pages)):
+                        page = pdf_reader_job.pages[page_num]
+                        pdf_data_jobdescription_string += page.extract_text()
+                # st.session_state["pdf_data_jobdescription"] = pdf_data_jobdescription activate and add sessio state if data is needed
+                system_prompt_job = sys_prompt_optimization.format(job=pdf_data_jobdescription_string)
+                try:
+                    res = openai.ChatCompletion.create(
+                        engine="gpt-4",
+                        temperature=0.2,
+                        messages=[
+                            {
+                                "role": "system",
+                                "content": system_prompt_job,
+                            },
+                        ],
+                    )
+                    # print(res.choices[0]["message"]["content"])
+                    output_string = f"""{res.choices[0]["message"]["content"]}"""
+                    st.session_state["optimized_job"] = output_string
+                    st.rerun()
+                except Exception as e:
+                    print(f"Fehler beim generieren der optimierten JD: {str(e)}")
+                    st.error("An error has occurred. Please reload the page or contact the admin.", icon="🚨")
+                # st.session_state["job_string"] = pdf_data_jobdescription_string
+                # print(output_string)
+        st.text_area("This is the AI-generated optimized job description. If necessary, change something to your liking:", value=st.session_state["optimized_job"], height=700, key="optimized_job_edited")
+        if st.button("Accept the job description"):
+            st.session_state["job_string"] = st.session_state["optimized_job_edited"]
+            st.rerun()
+
+st.write("Switch from a similarity search (default) to a hybrid search (activated)")
+st.toggle("Switch Search", key="search_type")
+
+st.write("Activate the following toggles to filter according to the respective properties:")
+col_screening, col_handoff, col_placed = st.columns([1,1,1])
+with col_screening:
+    st.toggle("Screened", key="screened")
+with col_handoff:
+    st.toggle("Handed over", key="handed")
+with col_placed:
+    st.toggle("Placed", key="placed")
+
+text_area_params = st.text_area(label="Add additional search parameters, which are separated by commas (e.g. master, phd, web developer, spanish)")
+
+submit = st.button("Search candidates",disabled= True if st.session_state["final_candidates"] else False)
+
+
+if not st.session_state["job"] and submit:
+    st.error("Please upload a job description to search for candidates")
+if st.session_state["docs_res"] and submit:
+    load_candidates(False)
+if (st.session_state["job_string"] and submit) or st.session_state["docs_res"]:
+    # if not st.session_state["job_string"]:
+    #     pdf_data_jobdescription = st.session_state["job"].read()
+    #     pdf_data_jobdescription_string = ""
+    #     pdf_reader_job = PdfReader(io.BytesIO(pdf_data_jobdescription))
+    #     for page_num in range(len(pdf_reader_job.pages)):
+    #             page = pdf_reader_job.pages[page_num]
+    #             pdf_data_jobdescription_string += page.extract_text()
+    #     # st.session_state["pdf_data_jobdescription"] = pdf_data_jobdescription activate and add sessio state if data is needed
+    #     st.session_state["job_string"] = pdf_data_jobdescription_string
+    if not st.session_state["docs_res"]:
+        load_candidates(False)
+    if not st.session_state["final_candidates"]:
+        for i,doc in enumerate(st.session_state["docs_res"]):
+            # print(doc)
+            cols_final = st.columns([6,1])
+            with cols_final[1]:
+                if st.button("Remove",use_container_width=True,key="btn_rm_cv_row_"+str(i)):
+                    # st.write(doc.page_content)
+                    st.session_state["docs_res"].pop(i)
+                    st.rerun()
+            with cols_final[0]:
+                # st.subheader(doc.metadata["source"])
+                with st.expander(doc[0].metadata["name"]+" with a search score of: "+str(round(doc[1] * 100, 3))+"%"):
+                    st.write(doc[0].page_content)
+        if len(st.session_state["docs_res"])>=10:    
+            if st.button("Accept candidates", key="accept_candidates_btn"):       
+                print("hello")
+                st.session_state["final_candidates"] = st.session_state["docs_res"].copy()
+                st.rerun()
+        else:
+            col_accept, col_empty ,col_load_new = st.columns([2, 3, 2])
+            with col_accept:
+                if st.button("Accept candidates", key="accept_candidates_btn"):       
+                    print("hello")
+                    st.session_state["final_candidates"] = st.session_state["docs_res"].copy()
+                    st.rerun()
+            with col_load_new:
+                if st.button("Load new candidates", key="load_new_candidates"):
+                    print("loading new candidates")
+                    load_candidates(True)
+                    st.rerun()
+    else:
+        print("Now Questions")
+        st.subheader("Your Candidates:")
+        st.write(", ".join(candidate[0].metadata["name"] for candidate in st.session_state["final_candidates"]))
+        # for i,candidate in enumerate(st.session_state["final_candidates"]):
+        #     st.write(candidate.metadata["source"])
+        cv_strings = "; Next CV: ".join(candidate[0].page_content for candidate in st.session_state["final_candidates"])
+        # print(len(cv_strings))
+        system = sys_prompt.format(job=st.session_state["job_string"], resume=st.session_state["final_candidates"][0][0].page_content, n=15)
+        if not st.session_state["ai_questions"]:
+            try:
+                # st.write("The questions are generated. This may take a short moment...")
+                st.info("The questions are generated. This may take a short moment.", icon="ℹ️")
+                with st.spinner("Loading..."):
+                    res = openai.ChatCompletion.create(
+                        engine="gpt-4",
+                        temperature=0.2,
+                        messages=[
+                            {
+                                "role": "system",
+                                "content": system,
+                            },
+                        ],
+                        )
+                    st.session_state["ai_questions"] = [item for item in res.choices[0]["message"]["content"].split("\n") if len(item) > 0]
+                    for i,q in enumerate(res.choices[0]["message"]["content"].split("\n")):
+                        st.session_state["disable_row_"+str(i)] = False
+                    st.rerun()
+            except Exception as e:
+                print(f"Fehler beim generieren der Fragen: {str(e)}")
+                st.error("An error has occurred. Please reload the page or contact the admin.", icon="🚨")
+        else:
+            if len(st.session_state["final_question_string"]) <= 0:
+                for i,question in enumerate(st.session_state["ai_questions"]):
+                    cols = st.columns([5,1])
+                    with cols[1]:
+                        # if st.button("Accept",use_container_width=True,key="btn_accept_row_"+str(i)):
+                        #     print("accept")
+                        #     pattern = re.compile(r"^[1-9][0-9]?\.")
+                        #     questions_length = len(st.session_state["final_question_string"])
+                        #     question_from_text_area = st.session_state["text_area_"+str(i)]
+                        #     question_to_append = str(questions_length+1)+"."+re.sub(pattern, "", question_from_text_area)
+                        #     st.session_state["final_question_string"].append(question_to_append)
+                        #     st.session_state["disable_row_"+str(i)] = True
+                        #     st.rerun() 
+                        if st.button("Delete",use_container_width=True,key="btn_del_row_"+str(i)):
+                            print("delete")
+                            st.session_state["ai_questions"].remove(question)
+                            st.rerun()
+                    with cols[0]:
+                        st.text_area(label="Question "+str(i+1)+":",value=question,label_visibility="collapsed",key="text_area_"+str(i),disabled=st.session_state["disable_row_"+str(i)])
+                st.write("If you are satisfied with the questions, then accept them. You can still sort them afterwards.")
+                if st.button("Accept all questions",use_container_width=True,key="accept_all_questions"):
+                    for i,question in enumerate(st.session_state["ai_questions"]):
+                            pattern = re.compile(r"^[1-9][0-9]?\.")
+                            questions_length = len(st.session_state["final_question_string"])
+                            question_from_text_area = st.session_state["text_area_"+str(i)]
+                            question_to_append = str(questions_length+1)+"."+re.sub(pattern, "", question_from_text_area)
+                            st.session_state["final_question_string"].append(question_to_append)
+                            st.session_state["disable_row_"+str(i)] = True
+                    st.rerun()
+            for i,final_q in enumerate(st.session_state["final_question_string"]):
+                cols_final = st.columns([5,1])
+                with cols_final[1]:
+                    if st.button("Up",use_container_width=True,key="btn_up_row_"+str(i),disabled=True if i == 0 else False):
+                        if i > 0:
+                            # Tausche das aktuelle Element mit dem vorherigen Element
+                            st.session_state.final_question_string[i], st.session_state.final_question_string[i - 1] = \
+                                st.session_state.final_question_string[i - 1], st.session_state.final_question_string[i]
+                            st.session_state.final_question_string = adjust_numbering(st.session_state.final_question_string)
+                            st.rerun()
+                    if st.button("Down",use_container_width=True,key="btn_down_row_"+str(i), disabled=True if i == len(st.session_state["final_question_string"])-1 else False):
+                        if i < len(st.session_state.final_question_string) - 1:
+                            # Tausche das aktuelle Element mit dem nächsten Element
+                            st.session_state.final_question_string[i], st.session_state.final_question_string[i + 1] = \
+                                st.session_state.final_question_string[i + 1], st.session_state.final_question_string[i]
+                            st.session_state.final_question_string = adjust_numbering(st.session_state.final_question_string)
+                            st.rerun()
+                with cols_final[0]:
+                    st.write(final_q)
+            if len(st.session_state["final_question_string"])>0:
+                st.text_input("Enter the email address to which the test emails should be sent:",key="recruiter_mail")
+                st.text_input("Enter the phone number to which the test SMS should be sent (With country code, e.g. +1 for the USA or +49 for Germany):",key="recruiter_phone")
+                st.text_input("Enter the job title:", key="job_title")
+                if st.button("Submit", use_container_width=True):
+                    with st.spinner("Generation and dispatch of mails. This process may take a few minutes..."):
+                        sg = sendgrid.SendGridAPIClient(api_key=os.environ.get('SENDGRID_API'))
+                        # Sender- und Empfänger-E-Mail-Adressen
+                        sender_email = "workgeniusjobevaluation@gmail.com"
+                        receiver_email = st.session_state["recruiter_mail"]
+                        print(receiver_email)
+                        subject = "Mails for potential candidates for the following position: "+st.session_state["job_title"]
+                        message = f"""Dear Recruiter,
+                        
+enclosed in the text file you will find the e-mails that are sent to the potential candidates. 
+
+The subject of the mail would be the following: Are you interested in a new position as a {st.session_state["job_title"]}? 
+
+Sincerely,
+Your Candidate-Search-Tool
+"""
+                        # SendGrid-E-Mail erstellen
+                        message = Mail(
+                            from_email=sender_email,
+                            to_emails=receiver_email,
+                            subject=subject,
+                            plain_text_content=message,
+                        )
+                        data = {
+                            "title": st.session_state["job_title"],
+                            "email": st.session_state["recruiter_mail"],
+                            "question_one": "",
+                            "question_two": "",
+                            "question_three": "",
+                        }
+                        json_data = json.dumps(data, ensure_ascii=False)
+                        # Eine zufällige UUID generieren
+                        random_uuid = uuid.uuid4()
+
+                        # Die UUID als String darstellen
+                        uuid_string = str(random_uuid)
+
+                        pdf_name = uuid_string
+                        cvs_data = []
+                        temp_pdf_file = "candidate_pdf.pdf"
+                        for candidate in st.session_state["final_candidates"]:
+                            styles = getSampleStyleSheet()
+                            pdf = SimpleDocTemplate(temp_pdf_file)
+                            flowables = [Paragraph(candidate[0].page_content, styles['Normal'])]
+                            pdf.build(flowables)
+                            with open(temp_pdf_file, 'rb') as pdf_file:
+                                bytes_data = pdf_file.read()
+                            cvs_data.append(bytes_data)
+                        os.remove(temp_pdf_file)
+                        candidate_links = upload_blob(pdf_name, json_data, st.session_state["job"].read(),cvs_data,True,st.session_state["final_question_string"])
+                        mail_txt_string = ""
+                        for i, candidate in enumerate(st.session_state["final_candidates"]):
+                            if i > 0:
+                                mail_txt_string += "\n\nMail to the "+str(i+1)+". candidate: "+candidate[0].metadata["name"]+" "+candidate[0].metadata["candidateId"]+" \n\n"
+                            else:
+                                mail_txt_string += "Mail to the "+str(i+1)+". candidate: "+candidate[0].metadata["name"]+" "+candidate[0].metadata["candidateId"]+" \n\n"
+                            mail_txt_string += generate_candidate_mail(candidate,candidate_links[i])
+                        # Summary in eine TXT Datei schreiben
+                        mail_txt_path = "mailattachment.txt"
+                        with open(mail_txt_path, 'wb') as summary_file:
+                            summary_file.write(mail_txt_string.encode('utf-8'))
+                        # Resume als Anhang hinzufügen
+                        with open(mail_txt_path, 'rb') as summary_file:
+                            encode_file_summary = base64.b64encode(summary_file.read()).decode()
+                            summary_attachment = Attachment()
+                            summary_attachment.file_content = FileContent(encode_file_summary)
+                            summary_attachment.file_name = FileName('candidate_mails.txt')
+                            summary_attachment.file_type = FileType('text/plain')
+                            summary_attachment.disposition = Disposition('attachment')
+                            message.attachment = summary_attachment
+                        try:
+                            response = sg.send(message)
+                            print("E-Mail wurde erfolgreich gesendet. Statuscode:", response.status_code)
+                            os.remove("mailattachment.txt")
+                        except Exception as e:
+                            print("Fehler beim Senden der E-Mail:", str(e))
+                            st.error("Unfortunately the mail dispatch did not work. Please reload the page and try again or contact the administrator. ", icon="🚨")
+                        try:
+                            bullets = generate_job_bullets(st.session_state["job_string"])
+                            client = Client(os.getenv("TWILIO_SID"), os.getenv("TWILIO_API"))
+                            message_body = f"Dear candidate,\n\nare you interested in the following position: \n\n"+st.session_state["job_title"]+"\n"+bullets+"\n\nThen please answer with 'yes'\n\nSincerely,\n"+"WorkGenius"
+                            message = client.messages.create(
+                                to=st.session_state["recruiter_phone"],
+                                from_="+1 857 214 8753",
+                                body=message_body
+                            )
+
+                            print(f"Message sent with SID: {message.sid}")
+                            st.success('The dispatch and the upload of the data was successful')
+                        except Exception as e:
+                            st.error("Unfortunately the SMS dispatch did not work. Please reload the page and try again or contact the administrator. ", icon="🚨")
+                            print("Fehler beim Senden der SMS:", str(e))