Job Title: {job.title}
-Application Deadline: {job.application_deadline.strftime('%B %d, %Y')}
+Application Deadline: {job.application_deadline.strftime("%B %d, %Y")}
Current Applications: {application_count}
Status: {job.get_status_display()}
@@ -1257,9 +1368,13 @@ def send_one_day_reminder(job_id): # Send email to each recipient for recipient_email in recipients: - _task_send_individual_email(subject, html_message, recipient_email, None, None, None) + _task_send_individual_email( + subject, html_message, recipient_email, None, None, None + ) - logger.info(f"Sent 1-day reminder for job {job_id} to {len(recipients)} recipients") + logger.info( + f"Sent 1-day reminder for job {job_id} to {len(recipients)} recipients" + ) except JobPosting.DoesNotExist: logger.error(f"Job {job_id} not found for 1-day reminder") @@ -1275,8 +1390,10 @@ def send_fifteen_minute_reminder(job_id): job = JobPosting.objects.get(pk=job_id) # Only send if job is still active - if job.status != 'ACTIVE': - logger.info(f"Job {job_id} is no longer active, skipping 15-minute reminder") + if job.status != "ACTIVE": + logger.info( + f"Job {job_id} is no longer active, skipping 15-minute reminder" + ) return # Get application count @@ -1304,7 +1421,7 @@ def send_fifteen_minute_reminder(job_id):Job Title: {job.title}
-Application Deadline: {job.application_deadline.strftime('%B %d, %Y at %I:%M %p')}
+Application Deadline: {job.application_deadline.strftime("%B %d, %Y at %I:%M %p")}
Current Applications: {application_count}
Status: {job.get_status_display()}
@@ -1320,9 +1437,13 @@ def send_fifteen_minute_reminder(job_id): # Send email to each recipient for recipient_email in recipients: - _task_send_individual_email(subject, html_message, recipient_email, None, None, None) + _task_send_individual_email( + subject, html_message, recipient_email, None, None, None + ) - logger.info(f"Sent 15-minute reminder for job {job_id} to {len(recipients)} recipients") + logger.info( + f"Sent 15-minute reminder for job {job_id} to {len(recipients)} recipients" + ) except JobPosting.DoesNotExist: logger.error(f"Job {job_id} not found for 15-minute reminder") @@ -1338,21 +1459,23 @@ def send_job_closed_notification(job_id): job = JobPosting.objects.get(pk=job_id) # Only proceed if job is currently active - if job.status != 'ACTIVE': - logger.info(f"Job {job_id} is already not active, skipping closed notification") + if job.status != "ACTIVE": + logger.info( + f"Job {job_id} is already not active, skipping closed notification" + ) return # Get final application count application_count = Application.objects.filter(job=job).count() # Update job status to closed - job.status = 'CLOSED' - job.save(update_fields=['status']) + job.status = "CLOSED" + job.save(update_fields=["status"]) # Also close the form template if job.template_form: job.template_form.is_active = False - job.template_form.save(update_fields=['is_active']) + job.template_form.save(update_fields=["is_active"]) # Determine recipients recipients = [] @@ -1369,14 +1492,16 @@ def send_job_closed_notification(job_id): return # Create email content - subject = f"Job '{job.title}' has closed - {application_count} applications received" + subject = ( + f"Job '{job.title}' has closed - {application_count} applications received" + ) html_message = f"""Job Title: {job.title}
-Application Deadline: {job.application_deadline.strftime('%B %d, %Y at %I:%M %p')}
+Application Deadline: {job.application_deadline.strftime("%B %d, %Y at %I:%M %p")}
Total Applications Received: {application_count}
Status: {job.get_status_display()}
@@ -1393,11 +1518,50 @@ def send_job_closed_notification(job_id): # Send email to each recipient for recipient_email in recipients: - _task_send_individual_email(subject, html_message, recipient_email, None, None, None) + _task_send_individual_email( + subject, html_message, recipient_email, None, None, None + ) - logger.info(f"Sent job closed notification for job {job_id} to {len(recipients)} recipients") + logger.info( + f"Sent job closed notification for job {job_id} to {len(recipients)} recipients" + ) except JobPosting.DoesNotExist: logger.error(f"Job {job_id} not found for closed notification") except Exception as e: - logger.error(f"Error sending job closed notification for job {job_id}: {str(e)}") + logger.error( + f"Error sending job closed notification for job {job_id}: {str(e)}" + ) + + + +def send_bulk_email_task( + recipient_emails, + subject: str, + template_name: str, + context: dict, +) -> str: + """ + Django-Q task to send a bulk email asynchronously. + """ + from .services.email_service import EmailService + + if not recipient_emails: + return json.dumps({"status": "error", "message": "No recipients provided."}) + + service = EmailService() + + # Execute the bulk sending method + processed_count = service.send_bulk_email( + recipient_emails=recipient_emails, + subject=subject, + template_name=template_name, + context=context, + ) + + # The return value is stored in the result object for monitoring + return json.dumps({ + "status": "success", + "count": processed_count, + "message": f"Attempted to send email to {len(recipient_emails)} recipients. Service reported processing {processed_count}." + }) \ No newline at end of file diff --git a/recruitment/tasks/email_tasks.py b/recruitment/tasks/email_tasks.py new file mode 100644 index 0000000..53cf8c7 --- /dev/null +++ b/recruitment/tasks/email_tasks.py @@ -0,0 +1,306 @@ +""" +Background email tasks for Django-Q integration. +""" + +import logging +from typing import Dict, Any +from django_q.tasks import async_task + +from .services.email_service import UnifiedEmailService +from .dto.email_dto import EmailConfig, BulkEmailConfig, EmailTemplate, EmailResult +from .email_templates import EmailTemplates + +logger = logging.getLogger(__name__) + + +def send_email_task(email_config_dict: Dict[str, Any]) -> Dict[str, Any]: + """ + Background task for sending individual emails. + + Args: + email_config_dict: Dictionary representation of EmailConfig + + Returns: + Dict with task result + """ + try: + # Reconstruct EmailConfig from dictionary + config = EmailConfig( + to_email=email_config_dict["to_email"], + subject=email_config_dict["subject"], + template_name=email_config_dict.get("template_name"), + context=email_config_dict.get("context", {}), + html_content=email_config_dict.get("html_content"), + attachments=email_config_dict.get("attachments", []), + priority=EmailPriority(email_config_dict.get("priority", "normal")), + cc_emails=email_config_dict.get("cc_emails", []), + bcc_emails=email_config_dict.get("bcc_emails", []), + reply_to=email_config_dict.get("reply_to"), + ) + + # Add sender and job objects if IDs provided + if email_config_dict.get("sender_id"): + from django.contrib.auth import get_user_model + + User = get_user_model() + try: + config.sender = User.objects.get(id=email_config_dict["sender_id"]) + except User.DoesNotExist: + logger.warning( + f"Sender user {email_config_dict['sender_id']} not found" + ) + + if email_config_dict.get("job_id"): + from .models import JobPosting + + try: + config.job = JobPosting.objects.get(id=email_config_dict["job_id"]) + except JobPosting.DoesNotExist: + logger.warning(f"Job {email_config_dict['job_id']} not found") + + # Send email using unified service + service = UnifiedEmailService() + result = service.send_email(config) + + return { + "success": result.success, + "message": result.message, + "recipient_count": result.recipient_count, + "error_details": result.error_details, + } + + except Exception as e: + error_msg = f"Background email task failed: {str(e)}" + logger.error(error_msg, exc_info=True) + return {"success": False, "message": error_msg, "error_details": str(e)} + + +def send_bulk_email_task(*args, **kwargs) -> Dict[str, Any]: + """ + Background task for sending bulk emails. + + Supports both old parameter format and new BulkEmailConfig format for backward compatibility. + + Args: + *args: Variable positional arguments (old format) + **kwargs: Variable keyword arguments (old format) + + Returns: + Dict with task result + """ + try: + config = None + + # Handle both old format and new BulkEmailConfig format + if len(args) == 1 and isinstance(args[0], dict): + # New format: BulkEmailConfig dictionary + bulk_config_dict = args[0] + + config = BulkEmailConfig( + subject=bulk_config_dict["subject"], + template_name=bulk_config_dict.get("template_name"), + recipients_data=bulk_config_dict["recipients_data"], + attachments=bulk_config_dict.get("attachments", []), + priority=EmailPriority(bulk_config_dict.get("priority", "normal")), + async_send=False, # Force sync processing in background + ) + + # Add sender and job objects if IDs provided + if bulk_config_dict.get("sender_id"): + from django.contrib.auth import get_user_model + + User = get_user_model() + try: + config.sender = User.objects.get(id=bulk_config_dict["sender_id"]) + except User.DoesNotExist: + logger.warning( + f"Sender user {bulk_config_dict['sender_id']} not found" + ) + + if bulk_config_dict.get("job_id"): + from .models import JobPosting + + try: + config.job = JobPosting.objects.get(id=bulk_config_dict["job_id"]) + except JobPosting.DoesNotExist: + logger.warning(f"Job {bulk_config_dict['job_id']} not found") + + else: + # Old format: individual parameters + subject = kwargs.get("subject") + customized_sends = kwargs.get("customized_sends", []) + attachments = kwargs.get("attachments") + sender_user_id = kwargs.get("sender_user_id") + job_id = kwargs.get("job_id") + + if not subject or not customized_sends: + return {"success": False, "message": "Missing required parameters"} + + # Convert old format to BulkEmailConfig + recipients_data = [] + for send_data in customized_sends: + if isinstance(send_data, dict): + recipients_data.append( + { + "email": send_data.get("email"), + "name": send_data.get( + "name", + send_data.get("email", "").split("@")[0] + if "@" in send_data.get("email", "") + else send_data.get("email", ""), + ), + "personalization": send_data.get("personalization", {}), + } + ) + else: + # Handle legacy format where customized_sends might be list of emails + recipients_data.append( + { + "email": send_data, + "name": send_data.split("@")[0] + if "@" in send_data + else send_data, + } + ) + + config = BulkEmailConfig( + subject=subject, + recipients_data=recipients_data, + attachments=attachments or [], + priority=EmailPriority.NORMAL, + async_send=False, # Force sync processing in background + ) + + # Handle old format with sender_user_id and job_id + if sender_user_id: + from django.contrib.auth import get_user_model + + User = get_user_model() + try: + config.sender = User.objects.get(id=sender_user_id) + except User.DoesNotExist: + logger.warning(f"Sender user {sender_user_id} not found") + + if job_id: + from .models import JobPosting + + try: + config.job = JobPosting.objects.get(id=job_id) + except JobPosting.DoesNotExist: + logger.warning(f"Job {job_id} not found") + + # Send bulk emails using unified service + service = UnifiedEmailService() + result = service.send_bulk_emails(config) + + return { + "success": result.success, + "message": result.message, + "recipient_count": result.recipient_count, + "error_details": result.error_details, + } + + except Exception as e: + error_msg = f"Background bulk email task failed: {str(e)}" + logger.error(error_msg, exc_info=True) + return {"success": False, "message": error_msg, "error_details": str(e)} + + +def send_interview_email_task(interview_data: Dict[str, Any]) -> Dict[str, Any]: + """ + Background task specifically for interview invitation emails. + + Args: + interview_data: Dictionary with interview details + + Returns: + Dict with task result + """ + try: + from .models import ScheduledInterview + from .dto.email_dto import EmailConfig, EmailTemplate, EmailPriority + + # Get interview object + interview_id = interview_data.get("interview_id") + if not interview_id: + raise ValueError("interview_id is required") + + try: + interview = ScheduledInterview.objects.get(id=interview_id) + except ScheduledInterview.DoesNotExist: + raise ValueError(f"Interview {interview_id} not found") + + # Build email configuration + service = UnifiedEmailService() + context = service.template_manager.build_interview_context( + interview.candidate, + interview.job, + { + "topic": f"Interview for {interview.job.title}", + "date_time": interview.interview_date, + "duration": "60 minutes", + "join_url": interview.zoom_meeting.join_url + if interview.zoom_meeting + else "", + "meeting_id": interview.zoom_meeting.meeting_id + if interview.zoom_meeting + else "", + }, + ) + + config = EmailConfig( + to_email=interview.candidate.email, + subject=service.template_manager.get_subject_line( + EmailTemplate.INTERVIEW_INVITATION_ALT, context + ), + template_name=EmailTemplate.INTERVIEW_INVITATION_ALT.value, + context=context, + priority=EmailPriority.HIGH, + ) + + # Send email + result = service.send_email(config) + + return { + "success": result.success, + "message": result.message, + "recipient_count": result.recipient_count, + "error_details": result.error_details, + "interview_id": interview_id, + } + + except Exception as e: + error_msg = f"Interview email task failed: {str(e)}" + logger.error(error_msg, exc_info=True) + return { + "success": False, + "message": error_msg, + "error_details": str(e), + "interview_id": interview_data.get("interview_id"), + } + + +def email_success_hook(task): + """ + Success hook for email tasks. + + Args: + task: Django-Q task object + """ + if task.success: + logger.info(f"Email task {task.id} completed successfully: {task.result}") + else: + logger.error(f"Email task {task.id} failed: {task.result}") + + +def email_failure_hook(task): + """ + Failure hook for email tasks. + + Args: + task: Django-Q task object + """ + logger.error(f"Email task {task.id} failed after retries: {task.result}") + + # Additional failure handling can be added here + # e.g., send notification to admin, log to external system, etc. diff --git a/recruitment/utils.py b/recruitment/utils.py index 13fea30..43933cc 100644 --- a/recruitment/utils.py +++ b/recruitment/utils.py @@ -1,6 +1,7 @@ """ Utility functions for recruitment app """ + from recruitment import models from django.conf import settings from datetime import datetime, timedelta, time, date @@ -19,6 +20,7 @@ from .models import Settings, Application logger = logging.getLogger(__name__) + def get_setting(key, default=None): """ Get a setting value from the database, with fallback to environment variables and default @@ -61,8 +63,7 @@ def set_setting(key, value): Settings: The created or updated setting object """ setting, created = Settings.objects.update_or_create( - key=key, - defaults={'value': str(value)} + key=key, defaults={"value": str(value)} ) return setting @@ -75,11 +76,11 @@ def get_zoom_config(): dict: Dictionary containing all Zoom settings """ return { - 'ZOOM_ACCOUNT_ID': get_setting('ZOOM_ACCOUNT_ID'), - 'ZOOM_CLIENT_ID': get_setting('ZOOM_CLIENT_ID'), - 'ZOOM_CLIENT_SECRET': get_setting('ZOOM_CLIENT_SECRET'), - 'ZOOM_WEBHOOK_API_KEY': get_setting('ZOOM_WEBHOOK_API_KEY'), - 'SECRET_TOKEN': get_setting('SECRET_TOKEN'), + "ZOOM_ACCOUNT_ID": get_setting("ZOOM_ACCOUNT_ID"), + "ZOOM_CLIENT_ID": get_setting("ZOOM_CLIENT_ID"), + "ZOOM_CLIENT_SECRET": get_setting("ZOOM_CLIENT_SECRET"), + "ZOOM_WEBHOOK_API_KEY": get_setting("ZOOM_WEBHOOK_API_KEY"), + "SECRET_TOKEN": get_setting("SECRET_TOKEN"), } @@ -91,9 +92,9 @@ def get_linkedin_config(): dict: Dictionary containing all LinkedIn settings """ return { - 'LINKEDIN_CLIENT_ID': get_setting('LINKEDIN_CLIENT_ID'), - 'LINKEDIN_CLIENT_SECRET': get_setting('LINKEDIN_CLIENT_SECRET'), - 'LINKEDIN_REDIRECT_URI': get_setting('LINKEDIN_REDIRECT_URI'), + "LINKEDIN_CLIENT_ID": get_setting("LINKEDIN_CLIENT_ID"), + "LINKEDIN_CLIENT_SECRET": get_setting("LINKEDIN_CLIENT_SECRET"), + "LINKEDIN_REDIRECT_URI": get_setting("LINKEDIN_REDIRECT_URI"), } @@ -123,9 +124,9 @@ def schedule_interviews(schedule, applications): interview = ScheduledInterview.objects.create( application=application, job=schedule.job, - interview_date=slot['date'], - interview_time=slot['time'], - status='scheduled' + interview_date=slot["date"], + interview_time=slot["time"], + status="scheduled", ) scheduled_interviews.append(interview) @@ -176,20 +177,22 @@ def _calculate_day_slots(schedule, date): break_start = datetime.combine(date, schedule.break_start_time) break_end = datetime.combine(date, schedule.break_end_time) - while current_datetime + timedelta(minutes=schedule.interview_duration) <= end_datetime: + while ( + current_datetime + timedelta(minutes=schedule.interview_duration) + <= end_datetime + ): # Skip break time if break_start and break_end: if break_start <= current_datetime < break_end: current_datetime = break_end continue - slots.append({ - 'date': date, - 'time': current_datetime.time() - }) + slots.append({"date": date, "time": current_datetime.time()}) # Move to next slot - current_datetime += timedelta(minutes=schedule.interview_duration + schedule.buffer_time) + current_datetime += timedelta( + minutes=schedule.interview_duration + schedule.buffer_time + ) return slots @@ -213,17 +216,17 @@ def json_to_markdown_table(data): for item in data: row = [] for header in headers: - value = item.get(header, '') + value = item.get(header, "") if isinstance(value, (dict, list)): value = str(value) row.append(str(value)) rows.append(row) else: # Simple list - headers = ['Value'] + headers = ["Value"] rows = [[str(item)] for item in data] elif isinstance(data, dict): - headers = ['Key', 'Value'] + headers = ["Key", "Value"] rows = [] for key, value in data.items(): if isinstance(value, (dict, list)): @@ -259,18 +262,18 @@ def initialize_default_settings(): """ # Zoom settings zoom_settings = { - 'ZOOM_ACCOUNT_ID': getattr(settings, 'ZOOM_ACCOUNT_ID', ''), - 'ZOOM_CLIENT_ID': getattr(settings, 'ZOOM_CLIENT_ID', ''), - 'ZOOM_CLIENT_SECRET': getattr(settings, 'ZOOM_CLIENT_SECRET', ''), - 'ZOOM_WEBHOOK_API_KEY': getattr(settings, 'ZOOM_WEBHOOK_API_KEY', ''), - 'SECRET_TOKEN': getattr(settings, 'SECRET_TOKEN', ''), + "ZOOM_ACCOUNT_ID": getattr(settings, "ZOOM_ACCOUNT_ID", ""), + "ZOOM_CLIENT_ID": getattr(settings, "ZOOM_CLIENT_ID", ""), + "ZOOM_CLIENT_SECRET": getattr(settings, "ZOOM_CLIENT_SECRET", ""), + "ZOOM_WEBHOOK_API_KEY": getattr(settings, "ZOOM_WEBHOOK_API_KEY", ""), + "SECRET_TOKEN": getattr(settings, "SECRET_TOKEN", ""), } # LinkedIn settings linkedin_settings = { - 'LINKEDIN_CLIENT_ID': getattr(settings, 'LINKEDIN_CLIENT_ID', ''), - 'LINKEDIN_CLIENT_SECRET': getattr(settings, 'LINKEDIN_CLIENT_SECRET', ''), - 'LINKEDIN_REDIRECT_URI': getattr(settings, 'LINKEDIN_REDIRECT_URI', ''), + "LINKEDIN_CLIENT_ID": getattr(settings, "LINKEDIN_CLIENT_ID", ""), + "LINKEDIN_CLIENT_SECRET": getattr(settings, "LINKEDIN_CLIENT_SECRET", ""), + "LINKEDIN_REDIRECT_URI": getattr(settings, "LINKEDIN_REDIRECT_URI", ""), } # Create settings if they don't exist @@ -281,7 +284,6 @@ def initialize_default_settings(): set_setting(key, value) - ##################################### @@ -292,17 +294,18 @@ def extract_text_from_pdf(file_path): with open(file_path, "rb") as f: reader = PdfReader(f) for page in reader.pages: - text += (page.extract_text() or "") + text += page.extract_text() or "" except Exception as e: logger.error(f"PDF extraction failed: {e}") raise return text.strip() + def score_resume_with_openrouter(prompt): print("model call") - OPENROUTER_API_URL = get_setting('OPENROUTER_API_URL') - OPENROUTER_API_KEY = get_setting('OPENROUTER_API_KEY') - OPENROUTER_MODEL = get_setting('OPENROUTER_MODEL') + OPENROUTER_API_URL = get_setting("OPENROUTER_API_URL") + OPENROUTER_API_KEY = get_setting("OPENROUTER_API_KEY") + OPENROUTER_MODEL = get_setting("OPENROUTER_MODEL") response = requests.post( url=OPENROUTER_API_URL, @@ -310,21 +313,21 @@ def score_resume_with_openrouter(prompt): "Authorization": f"Bearer {OPENROUTER_API_KEY}", "Content-Type": "application/json", }, - data=json.dumps({ - "model": OPENROUTER_MODEL, - "messages": [{"role": "user", "content": prompt}], - }, - ) + data=json.dumps( + { + "model": OPENROUTER_MODEL, + "messages": [{"role": "user", "content": prompt}], + }, + ), ) # print(response.status_code) # print(response.json()) res = {} if response.status_code == 200: res = response.json() - content = res["choices"][0]['message']['content'] + content = res["choices"][0]["message"]["content"] try: - - content = content.replace("```json","").replace("```","") + content = content.replace("```json", "").replace("```", "") res = json.loads(content) @@ -339,13 +342,13 @@ def score_resume_with_openrouter(prompt): # print(response) - # def match_resume_with_job_description(resume, job_description,prompt=""): # resume_doc = nlp(resume) # job_doc = nlp(job_description) # similarity = resume_doc.similarity(job_doc) # return similarity + def dashboard_callback(request, context): total_jobs = models.Job.objects.count() total_candidates = models.Candidate.objects.count() @@ -353,40 +356,41 @@ def dashboard_callback(request, context): job_titles = [job.title for job in jobs] job_app_counts = [job.candidates.count() for job in jobs] - context.update({ - "total_jobs": total_jobs, - "total_candidates": total_candidates, - "job_titles": job_titles, - "job_app_counts": job_app_counts, - }) + context.update( + { + "total_jobs": total_jobs, + "total_candidates": total_candidates, + "job_titles": job_titles, + "job_app_counts": job_app_counts, + } + ) return context - - def get_access_token(): - """Obtain an access token using server-to-server OAuth.""" - ZOOM_ACCOUNT_ID = get_setting("ZOOM_ACCOUNT_ID") - ZOOM_CLIENT_ID = get_setting("ZOOM_CLIENT_ID") - ZOOM_CLIENT_SECRET = get_setting("ZOOM_CLIENT_SECRET") - ZOOM_AUTH_URL = get_setting("ZOOM_AUTH_URL") + """Obtain an access token using server-to-server OAuth.""" + ZOOM_ACCOUNT_ID = get_setting("ZOOM_ACCOUNT_ID") + ZOOM_CLIENT_ID = get_setting("ZOOM_CLIENT_ID") + ZOOM_CLIENT_SECRET = get_setting("ZOOM_CLIENT_SECRET") + ZOOM_AUTH_URL = get_setting("ZOOM_AUTH_URL") - headers = { - "Content-Type": "application/x-www-form-urlencoded", - } - data = { - "grant_type": "account_credentials", - "account_id": ZOOM_ACCOUNT_ID, - } + headers = { + "Content-Type": "application/x-www-form-urlencoded", + } + data = { + "grant_type": "account_credentials", + "account_id": ZOOM_ACCOUNT_ID, + } - auth = (ZOOM_CLIENT_ID, ZOOM_CLIENT_SECRET) + auth = (ZOOM_CLIENT_ID, ZOOM_CLIENT_SECRET) - response = requests.post(ZOOM_AUTH_URL, headers=headers, data=data, auth=auth) + response = requests.post(ZOOM_AUTH_URL, headers=headers, data=data, auth=auth) + + if response.status_code == 200: + return response.json().get("access_token") + else: + raise Exception(f"Failed to obtain access token: {response.json()}") - if response.status_code == 200: - return response.json().get("access_token") - else: - raise Exception(f"Failed to obtain access token: {response.json()}") def create_zoom_meeting(topic, start_time, duration): """ @@ -416,21 +420,19 @@ def create_zoom_meeting(topic, start_time, duration): "mute_upon_entry": False, "approval_type": 2, "audio": "both", - "auto_recording": "none" - } + "auto_recording": "none", + }, } # Make API request to Zoom to create the meeting headers = { "Authorization": f"Bearer {access_token}", - "Content-Type": "application/json" + "Content-Type": "application/json", } - ZOOM_MEETING_URL = get_setting('ZOOM_MEETING_URL') + ZOOM_MEETING_URL = get_setting("ZOOM_MEETING_URL") print(ZOOM_MEETING_URL) response = requests.post( - ZOOM_MEETING_URL, - headers=headers, - json=meeting_details + ZOOM_MEETING_URL, headers=headers, json=meeting_details ) # Check response status @@ -440,25 +442,22 @@ def create_zoom_meeting(topic, start_time, duration): "status": "success", "message": "Meeting created successfully.", "meeting_details": { - "join_url": meeting_data['join_url'], - "meeting_id": meeting_data['id'], - "password": meeting_data['password'], - "host_email": meeting_data['host_email'] + "join_url": meeting_data["join_url"], + "meeting_id": meeting_data["id"], + "password": meeting_data["password"], + "host_email": meeting_data["host_email"], }, - "zoom_gateway_response": meeting_data + "zoom_gateway_response": meeting_data, } else: return { "status": "error", "message": "Failed to create meeting.", - "details": response.json() + "details": response.json(), } except Exception as e: - return { - "status": "error", - "message": str(e) - } + return {"status": "error", "message": str(e)} def list_zoom_meetings(next_page_token=None): @@ -473,20 +472,20 @@ def list_zoom_meetings(next_page_token=None): """ try: access_token = get_access_token() - user_id = 'me' + user_id = "me" params = {} if next_page_token: - params['next_page_token'] = next_page_token + params["next_page_token"] = next_page_token headers = { "Authorization": f"Bearer {access_token}", - "Content-Type": "application/json" + "Content-Type": "application/json", } response = requests.get( f"https://api.zoom.us/v2/users/{user_id}/meetings", headers=headers, - params=params + params=params, ) if response.status_code == 200: @@ -495,20 +494,17 @@ def list_zoom_meetings(next_page_token=None): "status": "success", "message": "Meetings retrieved successfully.", "meetings": meetings_data.get("meetings", []), - "next_page_token": meetings_data.get("next_page_token") + "next_page_token": meetings_data.get("next_page_token"), } else: return { "status": "error", "message": "Failed to retrieve meetings.", - "details": response.json() + "details": response.json(), } except Exception as e: - return { - "status": "error", - "message": str(e) - } + return {"status": "error", "message": str(e)} def get_zoom_meeting_details(meeting_id): @@ -527,26 +523,31 @@ def get_zoom_meeting_details(meeting_id): headers = { "Authorization": f"Bearer {access_token}", - "Content-Type": "application/json" + "Content-Type": "application/json", } response = requests.get( - f"https://api.zoom.us/v2/meetings/{meeting_id}", - headers=headers + f"https://api.zoom.us/v2/meetings/{meeting_id}", headers=headers ) if response.status_code == 200: meeting_data = response.json() datetime_fields = [ - 'start_time', 'created_at', 'updated_at', - 'password_changed_at', 'host_join_before_start_time', - 'audio_recording_start', 'recording_files_end' # Add any other known datetime fields + "start_time", + "created_at", + "updated_at", + "password_changed_at", + "host_join_before_start_time", + "audio_recording_start", + "recording_files_end", # Add any other known datetime fields ] for field_name in datetime_fields: if field_name in meeting_data and meeting_data[field_name] is not None: try: # Convert ISO 8601 string to datetime object, then back to ISO string # This ensures consistent string format, handling 'Z' for UTC - dt_obj = datetime.fromisoformat(meeting_data[field_name].replace('Z', '+00:00')) + dt_obj = datetime.fromisoformat( + meeting_data[field_name].replace("Z", "+00:00") + ) meeting_data[field_name] = dt_obj.isoformat() except (ValueError, TypeError) as e: logger.warning( @@ -559,20 +560,17 @@ def get_zoom_meeting_details(meeting_id): return { "status": "success", "message": "Meeting details retrieved successfully.", - "meeting_details": meeting_data + "meeting_details": meeting_data, } else: return { "status": "error", "message": "Failed to retrieve meeting details.", - "details": response.json() + "details": response.json(), } except Exception as e: - return { - "status": "error", - "message": str(e) - } + return {"status": "error", "message": str(e)} def update_zoom_meeting(meeting_id, updated_data): @@ -590,21 +588,18 @@ def update_zoom_meeting(meeting_id, updated_data): access_token = get_access_token() headers = { "Authorization": f"Bearer {access_token}", - "Content-Type": "application/json" + "Content-Type": "application/json", } response = requests.patch( f"https://api.zoom.us/v2/meetings/{meeting_id}/", headers=headers, - json=updated_data + json=updated_data, ) print(response.status_code) if response.status_code == 204: - return { - "status": "success", - "message": "Meeting updated successfully." - } + return {"status": "success", "message": "Meeting updated successfully."} else: print(response.json()) return { @@ -613,10 +608,7 @@ def update_zoom_meeting(meeting_id, updated_data): } except Exception as e: - return { - "status": "error", - "message": str(e) - } + return {"status": "error", "message": str(e)} def delete_zoom_meeting(meeting_id): @@ -631,31 +623,23 @@ def delete_zoom_meeting(meeting_id): """ try: access_token = get_access_token() - headers = { - "Authorization": f"Bearer {access_token}" - } + headers = {"Authorization": f"Bearer {access_token}"} response = requests.delete( - f"https://api.zoom.us/v2/meetings/{meeting_id}", - headers=headers + f"https://api.zoom.us/v2/meetings/{meeting_id}", headers=headers ) if response.status_code == 204: - return { - "status": "success", - "message": "Meeting deleted successfully." - } + return {"status": "success", "message": "Meeting deleted successfully."} else: return { "status": "error", "message": "Failed to delete meeting.", - "details": response.json() + "details": response.json(), } except Exception as e: - return { - "status": "error", - "message": str(e) - } + return {"status": "error", "message": str(e)} + def schedule_interviews(schedule): """ @@ -670,13 +654,15 @@ def schedule_interviews(schedule): available_slots = get_available_time_slots(schedule) if len(available_slots) < len(candidates): - raise ValueError(f"Not enough available slots. Required: {len(candidates)}, Available: {len(available_slots)}") + raise ValueError( + f"Not enough available slots. Required: {len(candidates)}, Available: {len(available_slots)}" + ) # Schedule interviews scheduled_count = 0 for i, candidate in enumerate(candidates): slot = available_slots[i] - interview_datetime = datetime.combine(slot['date'], slot['time']) + interview_datetime = datetime.combine(slot["date"], slot["time"]) # Create Zoom meeting meeting_topic = f"Interview for {schedule.job.title} - {candidate.name}" @@ -684,7 +670,7 @@ def schedule_interviews(schedule): topic=meeting_topic, start_time=interview_datetime, duration=schedule.interview_duration, - timezone=timezone.get_current_timezone_name() + timezone=timezone.get_current_timezone_name(), ) # Create scheduled interview record @@ -693,10 +679,10 @@ def schedule_interviews(schedule): job=schedule.job, zoom_meeting=meeting, schedule=schedule, - interview_date=slot['date'], - interview_time=slot['time'] + interview_date=slot["date"], + interview_time=slot["time"], ) - candidate.interview_date=interview_datetime + candidate.interview_date = interview_datetime # Send email to candidate send_interview_email(scheduled_interview) @@ -704,35 +690,62 @@ def schedule_interviews(schedule): return scheduled_count + def send_interview_email(scheduled_interview): """ - Send an interview invitation email to the candidate. + Send an interview invitation email to the candidate using the unified email service. """ - subject = f"Interview Invitation for {scheduled_interview.job.title}" + try: + from .services.email_service import UnifiedEmailService + from .dto.email_dto import EmailConfig, EmailTemplate, EmailPriority - context = { - 'candidate_name': scheduled_interview.candidate.name, - 'job_title': scheduled_interview.job.title, - 'company_name': scheduled_interview.job.company.name, - 'interview_date': scheduled_interview.interview_date, - 'interview_time': scheduled_interview.interview_time, - 'join_url': scheduled_interview.zoom_meeting.join_url, - 'meeting_id': scheduled_interview.zoom_meeting.meeting_id, - } + # Create unified email service + service = UnifiedEmailService() - # Render email templates - text_message = render_to_string('interviews/email/interview_invitation.txt', context) - html_message = render_to_string('interviews/email/interview_invitation.html', context) + # Build interview context using template manager + context = service.template_manager.build_interview_context( + scheduled_interview.candidate, + scheduled_interview.job, + { + "topic": f"Interview for {scheduled_interview.job.title}", + "date_time": scheduled_interview.interview_date, + "duration": "60 minutes", + "join_url": scheduled_interview.zoom_meeting.join_url + if scheduled_interview.zoom_meeting + else "", + "meeting_id": scheduled_interview.zoom_meeting.meeting_id + if scheduled_interview.zoom_meeting + else "", + }, + ) + + # Create email configuration + config = EmailConfig( + to_email=scheduled_interview.candidate.email, + subject=service.template_manager.get_subject_line( + EmailTemplate.INTERVIEW_INVITATION_ALT, context + ), + template_name=EmailTemplate.INTERVIEW_INVITATION_ALT.value, + context=context, + priority=EmailPriority.HIGH, + ) + + # Send email using unified service + result = service.send_email(config) + + if result.success: + logger.info( + f"Interview invitation sent to {scheduled_interview.candidate.email}" + ) + else: + logger.error(f"Failed to send interview invitation: {result.message}") + + return result.success + + except Exception as e: + logger.error(f"Error in send_interview_email: {str(e)}", exc_info=True) + return False - # Send email - send_mail( - subject=subject, - message=text_message, - from_email=settings.DEFAULT_FROM_EMAIL, - recipient_list=[scheduled_interview.candidate.email], - html_message=html_message, - fail_silently=False, - ) def get_available_time_slots(schedule): """ @@ -751,10 +764,12 @@ def get_available_time_slots(schedule): end_time = schedule.end_time # Calculate slot duration (interview duration + buffer time) - slot_duration = timedelta(minutes=schedule.interview_duration + schedule.buffer_time) + slot_duration = timedelta( + minutes=schedule.interview_duration + schedule.buffer_time + ) # Get breaks from the schedule - breaks = schedule.breaks if hasattr(schedule, 'breaks') and schedule.breaks else [] + breaks = schedule.breaks if hasattr(schedule, "breaks") and schedule.breaks else [] while current_date <= end_date: # Check if current day is a working day @@ -766,7 +781,9 @@ def get_available_time_slots(schedule): while True: # Calculate the end time of this slot - slot_end_time = (datetime.combine(current_date, current_time) + slot_duration).time() + slot_end_time = ( + datetime.combine(current_date, current_time) + slot_duration + ).time() # Check if the slot fits within the working hours if slot_end_time > end_time: @@ -777,11 +794,17 @@ def get_available_time_slots(schedule): for break_data in breaks: # Parse break times try: - break_start = datetime.strptime(break_data['start_time'], '%H:%M:%S').time() - break_end = datetime.strptime(break_data['end_time'], '%H:%M:%S').time() + break_start = datetime.strptime( + break_data["start_time"], "%H:%M:%S" + ).time() + break_end = datetime.strptime( + break_data["end_time"], "%H:%M:%S" + ).time() # Check if the slot overlaps with this break time - if not (current_time >= break_end or slot_end_time <= break_start): + if not ( + current_time >= break_end or slot_end_time <= break_start + ): conflict_with_break = True break except (ValueError, KeyError) as e: @@ -789,13 +812,12 @@ def get_available_time_slots(schedule): if not conflict_with_break: # Add this slot to available slots - slots.append({ - 'date': current_date, - 'time': current_time - }) + slots.append({"date": current_date, "time": current_time}) # Move to next slot - current_datetime = datetime.combine(current_date, current_time) + slot_duration + current_datetime = ( + datetime.combine(current_date, current_time) + slot_duration + ) current_time = current_datetime.time() # Move to next day @@ -827,7 +849,6 @@ def get_applications_from_request(request): yield None - def update_meeting(instance, updated_data): result = update_zoom_meeting(instance.meeting_id, updated_data) if result["status"] == "success": @@ -842,26 +863,36 @@ def update_meeting(instance, updated_data): instance.password = zoom_details.get("password", instance.password) instance.status = zoom_details.get("status") - instance.zoom_gateway_response = details_result.get("meeting_details") # Store full response + instance.zoom_gateway_response = details_result.get( + "meeting_details" + ) # Store full response instance.save() logger.info(f"Successfully updated Zoom meeting {instance.meeting_id}.") - return {"status": "success", "message": "Zoom meeting updated successfully."} + return { + "status": "success", + "message": "Zoom meeting updated successfully.", + } elif details_result["status"] == "error": # If fetching details fails, save with form data and log a warning logger.warning( f"Successfully updated Zoom meeting {instance.meeting_id}, but failed to fetch updated details. " f"Error: {details_result.get('message', 'Unknown error')}" ) - return {"status": "success", "message": "Zoom meeting updated successfully."} - - logger.warning(f"Failed to update Zoom meeting {instance.meeting_id}. Error: {result.get('message', 'Unknown error')}") - return {"status": "error", "message": result.get("message", "Zoom meeting update failed.")} - - + return { + "status": "success", + "message": "Zoom meeting updated successfully.", + } + logger.warning( + f"Failed to update Zoom meeting {instance.meeting_id}. Error: {result.get('message', 'Unknown error')}" + ) + return { + "status": "error", + "message": result.get("message", "Zoom meeting update failed."), + } def generate_random_password(): - import string,random + import string, random - return "".join(random.choices(string.ascii_letters + string.digits, k=12)) \ No newline at end of file + return "".join(random.choices(string.ascii_letters + string.digits, k=12)) diff --git a/recruitment/views.py b/recruitment/views.py index 342689b..7f8d897 100644 --- a/recruitment/views.py +++ b/recruitment/views.py @@ -93,7 +93,7 @@ from .forms import ( SettingsForm, InterviewCancelForm, InterviewEmailForm, - ApplicationStageForm + ApplicationStageForm, ) from .utils import generate_random_password from django.views.decorators.csrf import csrf_exempt @@ -189,10 +189,10 @@ class PersonListView(StaffRequiredMixin, ListView, LoginRequiredMixin): search_query = self.request.GET.get("search", "") if search_query: - queryset=queryset.filter( - Q(first_name=search_query) | - Q(last_name__icontains=search_query) | - Q(email__icontains=search_query) + queryset = queryset.filter( + Q(first_name=search_query) + | Q(last_name__icontains=search_query) + | Q(email__icontains=search_query) ) gender = self.request.GET.get("gender") if gender: @@ -227,9 +227,7 @@ class PersonCreateView(CreateView, LoginRequiredMixin, StaffOrAgencyRequiredMixi form_class = PersonForm success_url = reverse_lazy("person_list") - def form_valid(self, form): - instance = form.save() view = self.request.POST.get("view") if view == "portal": @@ -240,7 +238,6 @@ class PersonCreateView(CreateView, LoginRequiredMixin, StaffOrAgencyRequiredMixi instance.agency = agency instance.save() - # 2. Add the content to update (e.g., re-render the person list table) # response.content = render_to_string('recruitment/persons_table.html', return redirect("agency_portal_persons_list") @@ -945,7 +942,7 @@ def save_form_template(request): description=template_description, is_active=template_is_active, job_id=job_id if job_id else None, - created_by=request.user if request.user.is_authenticated else None + created_by=request.user if request.user.is_authenticated else None, ) # Create stages and fields @@ -989,7 +986,14 @@ def save_form_template(request): if "pattern" in validation_obj: pattern_value = validation_obj["pattern"] # Determine pattern type - if pattern_value in ["email", "phone", "url", "number", "alpha", "alphanum"]: + if pattern_value in [ + "email", + "phone", + "url", + "number", + "alpha", + "alphanum", + ]: validation_pattern = pattern_value elif pattern_value: # Custom pattern @@ -997,7 +1001,9 @@ def save_form_template(request): custom_pattern = pattern_value # Get other validation fields from validation object - required_message = validation_obj.get("errorMessage", required_message) + required_message = validation_obj.get( + "errorMessage", required_message + ) min_length = validation_obj.get("minLength", min_length) max_length = validation_obj.get("maxLength", max_length) min_value = validation_obj.get("minValue", min_value) @@ -1036,7 +1042,7 @@ def save_form_template(request): max_value=max_value, min_file_size=min_file_size, min_image_width=min_image_width, - min_image_height=min_image_height + min_image_height=min_image_height, ) return JsonResponse( @@ -1048,9 +1054,11 @@ def save_form_template(request): ) except Exception as e: import traceback + traceback.print_exc() return JsonResponse({"success": False, "error": str(e)}, status=400) + # @require_http_methods(["GET"]) # @login_required # def load_form_template(request, template_slug): @@ -1099,6 +1107,7 @@ def save_form_template(request): # } # ) + def load_form_template(request, template_slug): """Load an existing form template""" try: @@ -1106,16 +1115,16 @@ def load_form_template(request, template_slug): # Get stages with fields stages = [] - for stage in template.stages.all().order_by('order'): + for stage in template.stages.all().order_by("order"): stage_data = { "id": stage.id, "name": stage.name, "order": stage.order, "is_predefined": stage.is_predefined, - "fields": [] + "fields": [], } - for field in stage.fields.all().order_by('order'): + for field in stage.fields.all().order_by("order"): field_data = { "id": field.id, "type": field.field_type, @@ -1139,7 +1148,7 @@ def load_form_template(request, template_slug): "min_file_size": field.min_file_size, "min_image_width": field.min_image_width, "min_image_height": field.min_image_height, - "required_message": field.required_message + "required_message": field.required_message, } stage_data["fields"].append(field_data) @@ -1151,18 +1160,13 @@ def load_form_template(request, template_slug): "name": template.name, "description": template.description, "is_active": template.is_active, - "stages": stages + "stages": stages, } - return JsonResponse({ - "success": True, - "template": template_data - }) + return JsonResponse({"success": True, "template": template_data}) except Exception as e: - return JsonResponse({ - "success": False, - "error": str(e) - }, status=400) + return JsonResponse({"success": False, "error": str(e)}, status=400) + @login_required @staff_user_required @@ -1269,9 +1273,9 @@ def delete_form_template(request, template_id): # @staff_or_candidate_required def application_submit_form(request, slug): """Display the form as a step-by-step wizard""" - form_template=get_object_or_404(FormTemplate,slug=slug,is_active=True) + form_template = get_object_or_404(FormTemplate, slug=slug, is_active=True) if not request.user.is_authenticated: - return redirect("application_signup",slug=slug) + return redirect("application_signup", slug=slug) print(form_template.job.slug) job = get_object_or_404(JobPosting, slug=form_template.job.slug) if request.user.user_type == "candidate": @@ -2109,9 +2113,9 @@ def applications_document_review_view(request, slug): search_query = request.GET.get("q", "") if search_query: applications = applications.filter( - Q(person__first_name=search_query) | - Q(person__last_name__icontains=search_query) | - Q(person__email__icontains=search_query) + Q(person__first_name=search_query) + | Q(person__last_name__icontains=search_query) + | Q(person__email__icontains=search_query) ) context = { @@ -2602,19 +2606,26 @@ def agency_create(request): @login_required @staff_user_required def regenerate_agency_password(request, slug): - agency=HiringAgency.objects.get(slug=slug) - new_password=generate_random_password() - agency.generated_password=new_password - agency.save() - if agency.user is None: - messages.error(request, _("Error: The user account associated with this agency could not be found.")) + agency = HiringAgency.objects.get(slug=slug) + new_password = generate_random_password() + agency.generated_password = new_password + agency.save() + if agency.user is None: + messages.error( + request, + _( + "Error: The user account associated with this agency could not be found." + ), + ) # Redirect the staff user back to the agency detail page or list - return redirect('agency_detail', slug=agency.slug) # Or wherever appropriate - user=agency.user - user.set_password(new_password) - user.save() - messages.success(request, f'New password generated for agency "{agency.name}" successfully!') - return redirect("agency_detail", slug=agency.slug) + return redirect("agency_detail", slug=agency.slug) # Or wherever appropriate + user = agency.user + user.set_password(new_password) + user.save() + messages.success( + request, f'New password generated for agency "{agency.name}" successfully!' + ) + return redirect("agency_detail", slug=agency.slug) @login_required @@ -3134,7 +3145,6 @@ def agency_portal_persons_list(request): | Q(last_name__icontains=search_query) | Q(email__icontains=search_query) | Q(phone=search_query) - ) paginator = Paginator(persons, 20) # Show 20 persons per page @@ -3644,6 +3654,8 @@ def message_detail(request, message_id): def message_create(request): """Create a new message""" from .email_service import EmailService + from .services.email_service import UnifiedEmailService + from .dto.email_dto import EmailConfig, BulkEmailConfig, EmailPriority if request.method == "POST": form = MessageForm(request.user, request.POST) @@ -3663,15 +3675,26 @@ def message_create(request): + f"\n\n Sent by: {request.user.get_full_name()} ({request.user.email})" ) try: - email_result = async_task( - "recruitment.tasks._task_send_individual_email", + # Use new unified email service for background processing + # from .services.email_service import UnifiedEmailService + # from .dto.email_dto import EmailConfig, EmailPriority + + service = UnifiedEmailService() + + # Create email configuration + config = EmailConfig( + to_email=message.recipient.email, subject=message.subject, - body_message=body, - recipient=message.recipient.email, + html_content=body, attachments=None, - sender=False, - job=False, + sender=request.user + if request and hasattr(request, "user") + else None, + priority=EmailPriority.NORMAL, ) + + # Send email using unified service + email_result = service.send_email(config) if email_result: messages.success( request, "Message sent successfully via email!" @@ -4233,8 +4256,8 @@ def cancel_interview_for_application(request, slug): if form.is_valid(): scheduled_interview.status = scheduled_interview.InterviewStatus.CANCELLED - scheduled_interview.save(update_fields=['status']) - scheduled_interview.save(update_fields=['status']) # Saves the new status + scheduled_interview.save(update_fields=["status"]) + scheduled_interview.save(update_fields=["status"]) # Saves the new status form.save() # Saves form data @@ -4371,20 +4394,20 @@ def api_application_detail(request, candidate_id): def compose_application_email(request, slug): """Compose email to participants about a candidate""" from .email_service import send_bulk_email + from .services.email_service import EmailService + from .dto.email_dto import BulkEmailConfig, EmailPriority job = get_object_or_404(JobPosting, slug=slug) - candidate_ids=request.GET.getlist('candidate_ids') - candidates=Application.objects.filter(id__in=candidate_ids) + candidate_ids = request.GET.getlist("candidate_ids") + candidates = Application.objects.filter(id__in=candidate_ids) if request.method == "POST": candidate_ids = request.POST.getlist("candidate_ids") - print("candidate_ids from post:", candidate_ids) applications = Application.objects.filter(id__in=candidate_ids) form = CandidateEmailForm(job, applications, request.POST) if form.is_valid(): - print("form is valid ...") # Get email addresses email_addresses = form.get_email_addresses() @@ -4398,79 +4421,99 @@ def compose_application_email(request, slug): else: return redirect("dashboard") - message = form.get_formatted_message() subject = form.cleaned_data.get("subject") + message = form.get_formatted_message() - # Send emails using email service (no attachments, synchronous to avoid pickle issues) - print(email_addresses) - email_result = send_bulk_email( # - subject=subject, - message=message, - recipient_list=email_addresses, - request=request, - attachments=None, - async_task_=True, # Changed to False to avoid pickle issues - # from_interview=False, - job=job, + service = EmailService() + + # Prepare recipients data for bulk email + # recipients_data = [] + # for email_addr in email_addresses: + # recipients_data.append( + # { + # "email": email_addr, + # "name": email_addr.split("@")[0] + # if "@" in email_addr + # else email_addr, + # } + # ) + from django.conf import settings + async_task( + "recruitment.tasks.send_bulk_email_task", + email_addresses, + subject, + # message, + "emails/email_template.html", + { + "job": job, + "applications": applications, + "email_message": message, + "logo_url": settings.STATIC_URL + "image/kaauh.png", + }, ) + # Create bulk email configuration + # bulk_config = BulkEmailConfig( + # subject=subject, + # recipients_data=recipients_data, + # attachments=None, + # sender=request.user if request and hasattr(request, "user") else None, + # job=job, + # priority=EmailPriority.NORMAL, + # async_send=True, + # ) - if email_result["success"]: - for application in applications: - if hasattr(application, "person") and application.person: - try: - print(request.user) - print(application.person.user) - print(subject) - print(message) - print(job) + # Send bulk emails + # if email_result["success"]: + # for application in applications: + # if hasattr(application, "person") and application.person: + # try: + # Message.objects.create( + # sender=request.user, + # recipient=application.person.user, + # subject=subject, + # content=message, + # job=job, + # message_type="job_related", + # is_email_sent=True, + # email_address=application.person.email + # if application.person.email + # else application.email, + # ) - Message.objects.create( - sender=request.user, - recipient=application.person.user, - subject=subject, - content=message, - job=job, - message_type="job_related", - is_email_sent=True, - email_address=application.person.email - if application.person.email - else application.email, - ) + # except Exception as e: + # # Log error but don't fail the entire process + # print(f"Error creating message") - except Exception as e: - # Log error but don't fail the entire process - print(f"Error creating message") + # messages.success( + # request, + # f"Email will be sent shortly to recipient(s)", + # ) + # response = HttpResponse(status=200) + # response.headers["HX-Refresh"] = "true" + # return response + # # return redirect("applications_interview_view", slug=job.slug) + # else: + # messages.error( + # request, + # f"Failed to send email: {email_result.get('message', 'Unknown error')}", + # ) - messages.success( - request, - f"Email will be sent shortly to recipient(s)", - ) - response = HttpResponse(status=200) - response.headers["HX-Refresh"] = "true" - return response - # return redirect("applications_interview_view", slug=job.slug) - else: - messages.error( - request, - f"Failed to send email: {email_result.get('message', 'Unknown error')}", - ) + # # For HTMX requests, return error response + # if "HX-Request" in request.headers: + # return JsonResponse( + # { + # "success": False, + # "error": email_result.get( + # "message", "Failed to send email" + # ), + # } + # ) - # For HTMX requests, return error response - if "HX-Request" in request.headers: - return JsonResponse( - { - "success": False, - "error": email_result.get( - "message", "Failed to send email" - ), - } - ) - - return render( - request, - "includes/email_compose_form.html", - {"form": form, "job": job, "candidate": candidates}, - ) + # return render( + # request, + # "includes/email_compose_form.html", + # {"form": form, "job": job, "candidate": candidates}, + # ) else: # Form validation errors @@ -4780,10 +4823,10 @@ def interview_list(request): interviews = interviews.filter(job__slug=job_filter) if search_query: interviews = interviews.filter( - Q(application__person__first_name=search_query) | - Q(application__person__last_name__icontains=search_query) | - Q(application__person__email=search_query)| - Q(job__title__icontains=search_query) + Q(application__person__first_name=search_query) + | Q(application__person__last_name__icontains=search_query) + | Q(application__person__email=search_query) + | Q(job__title__icontains=search_query) ) # Pagination @@ -4806,32 +4849,35 @@ def interview_list(request): @staff_user_required def interview_detail(request, slug): """View details of a specific interview""" - from .forms import ScheduledInterviewUpdateStatusForm,OnsiteScheduleInterviewUpdateForm + from .forms import ( + ScheduledInterviewUpdateStatusForm, + OnsiteScheduleInterviewUpdateForm, + ) schedule = get_object_or_404(ScheduledInterview, slug=slug) interview = schedule.interview - application=schedule.application - job=schedule.job + application = schedule.application + job = schedule.job print(interview.location_type) if interview.location_type == "Remote": reschedule_form = ScheduledInterviewForm() else: reschedule_form = OnsiteScheduleInterviewUpdateForm() - reschedule_form.initial['physical_address'] = interview.physical_address - reschedule_form.initial['room_number'] = interview.room_number - reschedule_form.initial['topic'] = interview.topic - reschedule_form.initial['start_time'] = interview.start_time - reschedule_form.initial['duration'] = interview.duration + reschedule_form.initial["physical_address"] = interview.physical_address + reschedule_form.initial["room_number"] = interview.room_number + reschedule_form.initial["topic"] = interview.topic + reschedule_form.initial["start_time"] = interview.start_time + reschedule_form.initial["duration"] = interview.duration - meeting=interview - interview_email_form=InterviewEmailForm(job,application,schedule) + meeting = interview + interview_email_form = InterviewEmailForm(job, application, schedule) context = { - 'schedule': schedule, - 'interview': interview, - 'reschedule_form':reschedule_form, - 'interview_status_form':ScheduledInterviewUpdateStatusForm(), - 'cancel_form':InterviewCancelForm(instance=meeting), - 'interview_email_form':interview_email_form + "schedule": schedule, + "interview": interview, + "reschedule_form": reschedule_form, + "interview_status_form": ScheduledInterviewUpdateStatusForm(), + "cancel_form": InterviewCancelForm(instance=meeting), + "interview_email_form": interview_email_form, } return render(request, "interviews/interview_detail.html", context) @@ -5038,10 +5084,10 @@ def job_applicants_view(request, slug): # Apply filters if search_query: applications = applications.filter( - Q(person__first_name=search_query) | - Q(person__last_name__icontains=search_query) | - Q(person__email__icontains=search_query) | - Q(email__icontains=search_query) + Q(person__first_name=search_query) + | Q(person__last_name__icontains=search_query) + | Q(person__email__icontains=search_query) + | Q(email__icontains=search_query) ) if stage_filter: @@ -5390,11 +5436,11 @@ class JobApplicationListView(LoginRequiredMixin, StaffRequiredMixin, ListView): search_query = self.request.GET.get("search", "") if search_query: queryset = queryset.filter( - Q(first_name=search_query) | - Q(last_name__icontains=search_query) | - Q(email__icontains=search_query) | - Q(phone=search_query) | - Q(stage__icontains=search_query) + Q(first_name=search_query) + | Q(last_name__icontains=search_query) + | Q(email__icontains=search_query) + | Q(phone=search_query) + | Q(stage__icontains=search_query) ) # Filter for non-staff users @@ -5415,13 +5461,9 @@ class ApplicationListView(LoginRequiredMixin, StaffRequiredMixin, ListView): template_name = "recruitment/applications_list.html" context_object_name = "applications" paginate_by = 100 - def get_queryset(self): - queryset = ( - super() - .get_queryset() - .select_related("person", "job") - ) + def get_queryset(self): + queryset = super().get_queryset().select_related("person", "job") # Handle search search_query = self.request.GET.get("search", "") @@ -5430,10 +5472,10 @@ class ApplicationListView(LoginRequiredMixin, StaffRequiredMixin, ListView): if search_query: queryset = queryset.filter( - Q(person__first_name=search_query) | - Q(person__last_name__icontains=search_query) | - Q(person__email__icontains=search_query) | - Q(person__phone=search_query) + Q(person__first_name=search_query) + | Q(person__last_name__icontains=search_query) + | Q(person__email__icontains=search_query) + | Q(person__phone=search_query) ) if job: queryset = queryset.filter(job__slug=job) @@ -5503,7 +5545,7 @@ class ApplicationCreateView( context["nationality"] = nationality context["nationalities"] = nationalities context["search_query"] = self.request.GET.get("search", "") - context["person_form"]=PersonForm() + context["person_form"] = PersonForm() return context @@ -5884,10 +5926,10 @@ def applications_offer_view(request, slug): search_query = request.GET.get("search", "") if search_query: applications = applications.filter( - Q(first_name=search_query) | - Q(last_name__icontains=search_query) | - Q(email__icontains=search_query) | - Q(phone=search_query) + Q(first_name=search_query) + | Q(last_name__icontains=search_query) + | Q(email__icontains=search_query) + | Q(phone=search_query) ) applications = applications.order_by("-created_at") @@ -5914,10 +5956,10 @@ def applications_hired_view(request, slug): search_query = request.GET.get("search", "") if search_query: applications = applications.filter( - Q(first_name=search_query) | - Q(last_name__icontains=search_query) | - Q(email__icontains=search_query) | - Q(phone=search_query) + Q(first_name=search_query) + | Q(last_name__icontains=search_query) + | Q(email__icontains=search_query) + | Q(phone=search_query) ) applications = applications.order_by("-created_at") @@ -6154,10 +6196,10 @@ def export_applications_csv(request, slug, stage): search_query = request.GET.get("search", "") if search_query: applications = applications.filter( - Q(first_name=search_query) | - Q(last_name__icontains=search_query) | - Q(email__icontains=search_query) | - Q(phone=search_query) + Q(first_name=search_query) + | Q(last_name__icontains=search_query) + | Q(email__icontains=search_query) + | Q(phone=search_query) ) applications = applications.order_by("-created_at") @@ -6442,44 +6484,58 @@ def sync_history(request, job_slug=None): "job": job if job_slug else None, } - return render(request, 'recruitment/sync_history.html', context) + return render(request, "recruitment/sync_history.html", context) -def send_interview_email(request,slug): - schedule=get_object_or_404(ScheduledInterview,slug=slug) - application=schedule.application - job=application.job - form=InterviewEmailForm(job,application,schedule) - if request.method=='POST': - form=InterviewEmailForm(job, application, schedule, request.POST) +def send_interview_email(request, slug): + schedule = get_object_or_404(ScheduledInterview, slug=slug) + application = schedule.application + job = application.job + form = InterviewEmailForm(job, application, schedule) + if request.method == "POST": + form = InterviewEmailForm(job, application, schedule, request.POST) if form.is_valid(): - recipient=form.cleaned_data.get('to').strip() - body_message=form.cleaned_data.get('message') - subject=form.cleaned_data.get('subject') - sender=request.user - job=job + recipient = form.cleaned_data.get("to").strip() + body_message = form.cleaned_data.get("message") + subject = form.cleaned_data.get("subject") + sender = request.user + job = job try: - email_result = async_task('recruitment.tasks._task_send_individual_email', - subject=subject, - body_message=body_message, - recipient=recipient, - attachments=None, - sender=sender, - job=job - ) - if email_result: - messages.success(request, "Message sent successfully via email!") - else: + # Use new unified email service for background processing + from .services.email_service import UnifiedEmailService + from .dto.email_dto import EmailConfig, EmailPriority - messages.warning(request, f"email failed: {email_result.get('message', 'Unknown error')}") + service = UnifiedEmailService() + + # Create email configuration + config = EmailConfig( + to_email=recipient, + subject=subject, + html_content=body_message, + attachments=None, + sender=sender, + job=job, + priority=EmailPriority.NORMAL, + ) + + # Send email using background task + email_result = service.send_email(config) + if email_result: + messages.success(request, "Message sent successfully via email!") + else: + messages.warning( + request, + f"email failed: {email_result.get('message', 'Unknown error')}", + ) except Exception as e: - - messages.warning(request, f"Message saved but email sending failed: {str(e)}") + messages.warning( + request, f"Message saved but email sending failed: {str(e)}" + ) else: - form=InterviewEmailForm(job,application,schedule) - else: # GET request + form = InterviewEmailForm(job, application, schedule) + else: # GET request form = InterviewEmailForm(job, application, schedule) # This is the final return, which handles GET requests and invalid POST requests. - return redirect('interview_detail',slug=schedule.slug) + return redirect("interview_detail", slug=schedule.slug) diff --git a/templates/emails/email_template.html b/templates/emails/email_template.html index 45cce84..41f3653 100644 --- a/templates/emails/email_template.html +++ b/templates/emails/email_template.html @@ -96,22 +96,21 @@{{ email_message|safe }}
{% if cta_link %} - + {% endif %}If you have any questions, please reply to this email.
Thank you,
-The **[Your Organization Name]** Team
+King Abdullah bin Abdulaziz University Hospital
{% endblock %} diff --git a/test_bulk_email_fix.py b/test_bulk_email_fix.py new file mode 100644 index 0000000..575d0e6 --- /dev/null +++ b/test_bulk_email_fix.py @@ -0,0 +1,47 @@ +#!/usr/bin/env python3 +""" +Simple test for bulk email task without Django setup. +""" + +import sys +import os + +# Add project root to path +sys.path.insert(0, "/home/ismail/projects/ats/kaauh_ats") + + +def test_bulk_email_task(): + """Test the bulk email task function directly.""" + try: + # Import the function + from recruitment.tasks.email_tasks import send_bulk_email_task + + # Test new format + result = send_bulk_email_task( + { + "subject": "Test Subject", + "recipients_data": [{"email": "test@example.com", "name": "Test User"}], + "sender_id": 1, + "job_id": 1, + } + ) + + print("New format result:", result) + print("Success:", result.get("success", False)) + print("Message:", result.get("message", "")) + + return result.get("success", False) + + except Exception as e: + print(f"Error: {e}") + return False + + +if __name__ == "__main__": + print("Testing bulk email task...") + success = test_bulk_email_task() + + if success: + print("โ Bulk email task test PASSED") + else: + print("โ Bulk email task test FAILED") diff --git a/test_bulk_email_simple.py b/test_bulk_email_simple.py new file mode 100644 index 0000000..7d7ba32 --- /dev/null +++ b/test_bulk_email_simple.py @@ -0,0 +1,64 @@ +#!/usr/bin/env python3 +""" +Test the fixed bulk email task without Django setup. +""" + +import sys +import os + +# Add project root to path +sys.path.insert(0, "/home/ismail/projects/ats/kaauh_ats") + + +def test_bulk_email_task(): + """Test the bulk email task function directly.""" + try: + # Import the function directly + from recruitment.tasks.email_tasks import send_bulk_email_task + + # Test new format + result1 = send_bulk_email_task( + { + "subject": "Test Subject", + "recipients_data": [{"email": "test@example.com", "name": "Test User"}], + "sender_id": 1, + "job_id": 1, + } + ) + + print("โ New format test result:", result1) + + # Test old format + result2 = send_bulk_email_task( + subject="Test Subject", + customized_sends=[{"email": "test@example.com", "name": "Test User"}], + sender_user_id=1, + job_id=1, + ) + + print("โ Old format test result:", result2) + + # Check if both work + success1 = result1.get("success", False) + success2 = result2.get("success", False) + + if success1 and success2: + print("โ Both formats work correctly!") + return True + else: + print("โ One or both formats failed") + return False + + except Exception as e: + print(f"โ Test failed: {e}") + return False + + +if __name__ == "__main__": + print("Testing bulk email task function...") + success = test_bulk_email_task() + + if success: + print("๐ Bulk email task function is working correctly!") + else: + print("โ Bulk email task function has issues") diff --git a/test_email_foundation.py b/test_email_foundation.py new file mode 100644 index 0000000..56f222c --- /dev/null +++ b/test_email_foundation.py @@ -0,0 +1,162 @@ +#!/usr/bin/env python3 +""" +Test script to verify email refactoring foundation setup. +""" + +import sys +import os + +# Add project root to path +sys.path.insert(0, "/home/ismail/projects/ats/kaauh_ats") + + +def test_imports(): + """Test that all new modules can be imported.""" + print("Testing imports...") + + try: + from recruitment.dto.email_dto import ( + EmailConfig, + BulkEmailConfig, + EmailTemplate, + EmailPriority, + EmailResult, + ) + + print("โ Email DTO imports successful") + except Exception as e: + print(f"โ Email DTO import failed: {e}") + return False + + try: + from recruitment.email_templates import EmailTemplates + + print("โ Email templates import successful") + except Exception as e: + print(f"โ Email templates import failed: {e}") + return False + + try: + from recruitment.services.email_service import UnifiedEmailService + + print("โ Email service import successful") + except Exception as e: + print(f"โ Email service import failed: {e}") + return False + + return True + + +def test_email_config(): + """Test EmailConfig validation.""" + print("\nTesting EmailConfig...") + + try: + from recruitment.dto.email_dto import EmailConfig, EmailPriority + + # Valid config + config = EmailConfig( + to_email="test@example.com", + subject="Test Subject", + template_name="emails/test.html", + context={"name": "Test User"}, + ) + print("โ Valid EmailConfig created successfully") + + # Invalid config (missing required fields) + try: + invalid_config = EmailConfig( + to_email="", subject="", template_name="emails/test.html" + ) + print("โ EmailConfig validation failed - should have raised ValueError") + return False + except ValueError: + print("โ EmailConfig validation working correctly") + + return True + except Exception as e: + print(f"โ EmailConfig test failed: {e}") + return False + + +def test_template_manager(): + """Test EmailTemplates functionality.""" + print("\nTesting EmailTemplates...") + + try: + from recruitment.email_templates import EmailTemplates + + # Test base context + base_context = EmailTemplates.get_base_context() + if isinstance(base_context, dict) and "company_name" in base_context: + print("โ Base context generation working") + else: + print("โ Base context generation failed") + return False + + # Test interview context + class MockCandidate: + def __init__(self): + self.full_name = "Test Candidate" + self.name = "Test Candidate" + self.email = "test@example.com" + self.phone = "123-456-7890" + + class MockJob: + def __init__(self): + self.title = "Test Job" + self.department = "IT" + + candidate = MockCandidate() + job = MockJob() + + interview_context = EmailTemplates.build_interview_context(candidate, job) + if ( + isinstance(interview_context, dict) + and "candidate_name" in interview_context + and "job_title" in interview_context + ): + print("โ Interview context generation working") + else: + print("โ Interview context generation failed") + return False + + return True + except Exception as e: + print(f"โ EmailTemplates test failed: {e}") + return False + + +def main(): + """Run all tests.""" + print("=" * 50) + print("Email Refactoring Foundation Tests") + print("=" * 50) + + tests = [ + test_imports, + test_email_config, + test_template_manager, + ] + + passed = 0 + total = len(tests) + + for test in tests: + if test(): + passed += 1 + + print("\n" + "=" * 50) + print(f"Results: {passed}/{total} tests passed") + + if passed == total: + print("๐ All foundation tests passed!") + return True + else: + print("โ Some tests failed. Check the errors above.") + return False + + +if __name__ == "__main__": + success = main() + sys.exit(0 if success else 1) diff --git a/test_email_integration.py b/test_email_integration.py new file mode 100644 index 0000000..cea6b2f --- /dev/null +++ b/test_email_integration.py @@ -0,0 +1,242 @@ +#!/usr/bin/env python3 +""" +Integration test for email refactoring. +Tests the complete email system end-to-end. +""" + +import sys +import os + +# Add project root to path +sys.path.insert(0, "/home/ismail/projects/ats/kaauh_ats") + + +def test_complete_email_workflow(): + """Test complete email workflow with new unified service.""" + print("Testing complete email workflow...") + + try: + # Test 1: Import all components + from recruitment.services.email_service import UnifiedEmailService + from recruitment.dto.email_dto import ( + EmailConfig, + BulkEmailConfig, + EmailTemplate, + EmailPriority, + ) + from recruitment.email_templates import EmailTemplates + + print("โ All imports successful") + + # Test 2: Create unified service + service = UnifiedEmailService() + template_manager = EmailTemplates() + print("โ Service and template manager created") + + # Test 3: Create email configurations + single_config = EmailConfig( + to_email="test@example.com", + subject="Test Single Email", + template_name=EmailTemplate.BRANDED_BASE.value, + context={ + "user_name": "Test User", + "email_message": "This is a test message", + "cta_link": "https://example.com", + "cta_text": "Click Here", + }, + priority=EmailPriority.HIGH, + ) + print("โ Single email config created") + + bulk_config = BulkEmailConfig( + subject="Test Bulk Email", + template_name=EmailTemplate.BRANDED_BASE.value, + recipients_data=[ + { + "email": "user1@example.com", + "name": "User One", + "personalization": {"department": "Engineering"}, + }, + { + "email": "user2@example.com", + "name": "User Two", + "personalization": {"department": "Marketing"}, + }, + ], + priority=EmailPriority.NORMAL, + async_send=False, # Test synchronous + ) + print("โ Bulk email config created") + + # Test 4: Template context building + base_context = template_manager.get_base_context() + interview_context = template_manager.build_interview_context( + type( + "MockCandidate", + (), + { + "full_name": "Test Candidate", + "name": "Test Candidate", + "email": "test@example.com", + "phone": "123-456-7890", + }, + )(), + type("MockJob", (), {"title": "Test Job", "department": "IT"})(), + { + "topic": "Test Interview", + "date_time": "2024-01-01 10:00", + "duration": "60 minutes", + "join_url": "https://zoom.us/test", + }, + ) + print("โ Template context building works") + + # Test 5: Subject line generation + subject = template_manager.get_subject_line( + EmailTemplate.INTERVIEW_INVITATION, interview_context + ) + print(f"โ Subject generation works: {subject}") + + # Test 6: Validation + try: + invalid_config = EmailConfig( + to_email="", # Invalid + subject="", + template_name="test.html", + ) + print("โ Validation should have failed") + return False + except ValueError: + print("โ EmailConfig validation working correctly") + + print("\n๐ Complete workflow test passed!") + print("All components working together correctly.") + + return True + + except Exception as e: + print(f"โ Complete workflow test failed: {e}") + import traceback + + traceback.print_exc() + return False + + +def test_migration_compatibility(): + """Test that migrated functions maintain compatibility.""" + print("\nTesting migration compatibility...") + + try: + # Test legacy function access + from recruitment.utils import send_interview_email + from recruitment.email_service import ( + EmailService, + send_interview_invitation_email, + send_bulk_email, + ) + + print("โ Legacy functions still accessible") + + # Test that they have expected signatures + import inspect + + # Check send_interview_email signature + sig = inspect.signature(send_interview_email) + expected_params = ["scheduled_interview"] + actual_params = list(sig.parameters.keys()) + + if all(param in actual_params for param in expected_params): + print("โ send_interview_email signature compatible") + else: + print(f"โ send_interview_email signature mismatch: {actual_params}") + return False + + # Check EmailService class + if hasattr(EmailService, "send_email"): + print("โ EmailService.send_email method available") + else: + print("โ EmailService.send_email method missing") + return False + + return True + + except Exception as e: + print(f"โ Migration compatibility test failed: {e}") + return False + + +def test_error_handling(): + """Test error handling in new service.""" + print("\nTesting error handling...") + + try: + from recruitment.services.email_service import UnifiedEmailService + from recruitment.dto.email_dto import EmailConfig + + service = UnifiedEmailService() + + # Test with invalid template (should handle gracefully) + config = EmailConfig( + to_email="test@example.com", + subject="Test Error Handling", + template_name="nonexistent/template.html", # This should cause an error + context={"test": "data"}, + ) + + # This should not crash, but handle the error gracefully + result = service.send_email(config) + + # We expect this to fail gracefully, not crash + if not result.success: + print("โ Error handling working - graceful failure") + else: + print("โ Error handling issue - should have failed") + return False + + return True + + except Exception as e: + print(f"โ Error handling test failed (crashed): {e}") + return False + + +def main(): + """Run all integration tests.""" + print("=" * 70) + print("Email Refactoring Integration Tests") + print("=" * 70) + + tests = [ + test_complete_email_workflow, + test_migration_compatibility, + test_error_handling, + ] + + passed = 0 + total = len(tests) + + for test in tests: + if test(): + passed += 1 + + print("\n" + "=" * 70) + print(f"Integration Test Results: {passed}/{total} tests passed") + + if passed == total: + print("๐ All integration tests passed!") + print("\n๐ Phase 3 Summary:") + print("โ Views integration ready") + print("โ Complete workflow functional") + print("โ Migration compatibility maintained") + print("โ Error handling robust") + print("โ All components working together") + print("\n๐ Email refactoring complete and ready for production!") + return True + else: + print("โ Some integration tests failed. Check errors above.") + return False + + +if __name__ == "__main__": + success = main() + sys.exit(0 if success else 1) diff --git a/test_email_migrations.py b/test_email_migrations.py new file mode 100644 index 0000000..295a3dc --- /dev/null +++ b/test_email_migrations.py @@ -0,0 +1,255 @@ +#!/usr/bin/env python3 +""" +Test script to verify email refactoring migrations work correctly. +""" + +import sys +import os + +# Add project root to path and configure Django +sys.path.insert(0, "/home/ismail/projects/ats/kaauh_ats") +os.environ.setdefault("DJANGO_SETTINGS_MODULE", "NorahUniversity.settings") + +import django + +django.setup() + + +def test_unified_email_service(): + """Test the new UnifiedEmailService directly.""" + print("Testing UnifiedEmailService...") + + try: + from recruitment.services.email_service import UnifiedEmailService + from recruitment.dto.email_dto import EmailConfig, EmailPriority + + service = UnifiedEmailService() + + # Test basic email config + config = EmailConfig( + to_email="test@example.com", + subject="Test Subject", + html_content="