6267 lines
229 KiB
Python
6267 lines
229 KiB
Python
import json
|
|
import io
|
|
import zipfile
|
|
from django.forms import HiddenInput
|
|
from django.core.paginator import Paginator
|
|
from django.utils.translation import gettext as _
|
|
from django.contrib.auth import get_user_model, authenticate, login, logout
|
|
from django.contrib.auth.decorators import login_required
|
|
from django.contrib.admin.views.decorators import staff_member_required
|
|
from django.contrib.auth.mixins import LoginRequiredMixin
|
|
from .decorators import (
|
|
agency_user_required,
|
|
candidate_user_required,
|
|
staff_user_required,
|
|
staff_or_agency_required,
|
|
staff_or_candidate_required,
|
|
AgencyRequiredMixin,
|
|
CandidateRequiredMixin,
|
|
StaffRequiredMixin,
|
|
StaffOrAgencyRequiredMixin,
|
|
StaffOrCandidateRequiredMixin,
|
|
)
|
|
from .forms import (
|
|
StaffUserCreationForm,
|
|
ToggleAccountForm,
|
|
JobPostingStatusForm,
|
|
LinkedPostContentForm,
|
|
CandidateEmailForm,
|
|
InterviewForm,
|
|
ProfileImageUploadForm,
|
|
ParticipantsSelectForm,
|
|
ApplicationForm,
|
|
PasswordResetForm,
|
|
StaffAssignmentForm,
|
|
)
|
|
from django.views.decorators.csrf import csrf_exempt
|
|
from django.views.decorators.http import require_http_methods
|
|
from django.http import HttpResponse, JsonResponse
|
|
from datetime import datetime, time, timedelta
|
|
from django.views import View
|
|
from django.urls import reverse
|
|
from django.conf import settings
|
|
from django.utils import timezone
|
|
from django.db.models import FloatField, CharField, DurationField
|
|
from django.db.models import (
|
|
F,
|
|
IntegerField,
|
|
Count,
|
|
Avg,
|
|
Sum,
|
|
Q,
|
|
ExpressionWrapper,
|
|
fields,
|
|
Value
|
|
)
|
|
from django.db.models.functions import Coalesce, Cast, Replace, NullIf
|
|
from django.db.models.functions import Cast, Coalesce, TruncDate
|
|
from django.db.models.fields.json import KeyTextTransform
|
|
from django.db.models.expressions import ExpressionWrapper
|
|
from django.urls import reverse_lazy
|
|
from django.db.models import Count, Avg, F, Q
|
|
from .forms import (
|
|
ZoomMeetingForm,
|
|
CandidateExamDateForm,
|
|
JobPostingForm,
|
|
JobPostingImageForm,
|
|
InterviewNoteForm,
|
|
InterviewScheduleForm,
|
|
FormTemplateForm,
|
|
SourceForm,
|
|
HiringAgencyForm,
|
|
AgencyJobAssignmentForm,
|
|
AgencyAccessLinkForm,
|
|
AgencyApplicationSubmissionForm,
|
|
AgencyLoginForm,
|
|
PortalLoginForm,
|
|
MessageForm,
|
|
PersonForm,
|
|
OnsiteLocationForm,
|
|
OnsiteReshuduleForm,
|
|
OnsiteScheduleForm,
|
|
InterviewEmailForm
|
|
)
|
|
from easyaudit.models import CRUDEvent, LoginEvent, RequestEvent
|
|
from rest_framework import viewsets
|
|
from django.contrib import messages
|
|
from django.core.paginator import Paginator, EmptyPage, PageNotAnInteger
|
|
from .linkedin_service import LinkedInService
|
|
from .serializers import JobPostingSerializer, ApplicationSerializer
|
|
from django.shortcuts import get_object_or_404, render, redirect
|
|
from django.views.generic import (
|
|
CreateView,
|
|
UpdateView,
|
|
DetailView,
|
|
ListView,
|
|
DeleteView,
|
|
)
|
|
from .utils import (
|
|
create_zoom_meeting,
|
|
delete_zoom_meeting,
|
|
get_candidates_from_request,
|
|
update_meeting,
|
|
update_zoom_meeting,
|
|
get_zoom_meeting_details,
|
|
schedule_interviews,
|
|
get_available_time_slots,
|
|
)
|
|
from django.views.decorators.csrf import ensure_csrf_cookie
|
|
from django.views.decorators.http import require_POST
|
|
from .models import (
|
|
FormTemplate,
|
|
FormStage,
|
|
FormField,
|
|
FieldResponse,
|
|
FormSubmission,
|
|
InterviewSchedule,
|
|
BreakTime,
|
|
ZoomMeetingDetails,
|
|
Application,
|
|
Person,
|
|
JobPosting,
|
|
ScheduledInterview,
|
|
JobPostingImage,
|
|
|
|
HiringAgency,
|
|
AgencyJobAssignment,
|
|
AgencyAccessLink,
|
|
Notification,
|
|
Source,
|
|
Message,
|
|
Document,
|
|
InterviewLocation,
|
|
InterviewNote,
|
|
OnsiteLocationDetails
|
|
)
|
|
|
|
|
|
import logging
|
|
from datastar_py.django import (
|
|
DatastarResponse,
|
|
ServerSentEventGenerator as SSE,
|
|
read_signals,
|
|
)
|
|
from django.db import transaction
|
|
from django_q.tasks import async_task
|
|
from django.db.models import Prefetch
|
|
from django.db.models import Q, Count, Avg
|
|
from django.db.models import FloatField
|
|
from django.urls import reverse_lazy
|
|
|
|
logger = logging.getLogger(__name__)
|
|
|
|
User = get_user_model()
|
|
|
|
|
|
class PersonListView(StaffRequiredMixin, ListView):
|
|
model = Person
|
|
template_name = "people/person_list.html"
|
|
context_object_name = "people_list"
|
|
def get_queryset(self):
|
|
queryset=super().get_queryset()
|
|
gender=self.request.GET.get('gender')
|
|
if gender:
|
|
queryset=queryset.filter(gender=gender)
|
|
|
|
nationality=self.request.GET.get('nationality')
|
|
if nationality:
|
|
queryset=queryset.filter(nationality=nationality)
|
|
|
|
return queryset
|
|
def get_context_data(self, **kwargs):
|
|
context=super().get_context_data(**kwargs)
|
|
# We query the base model to ensure we list ALL options, not just those currently displayed.
|
|
nationalities = self.model.objects.values_list('nationality', flat=True).filter(
|
|
nationality__isnull=False
|
|
).distinct().order_by('nationality')
|
|
|
|
nationality=self.request.GET.get('nationality')
|
|
context['nationality']=nationality
|
|
context['nationalities']=nationalities
|
|
return context
|
|
|
|
|
|
|
|
class PersonCreateView(CreateView):
|
|
model = Person
|
|
template_name = "people/create_person.html"
|
|
form_class = PersonForm
|
|
success_url = reverse_lazy("person_list")
|
|
print("from agency")
|
|
def form_valid(self, form):
|
|
if "HX-Request" in self.request.headers:
|
|
instance = form.save()
|
|
view = self.request.POST.get("view")
|
|
if view == "portal":
|
|
slug = self.request.POST.get("agency")
|
|
if slug:
|
|
agency = HiringAgency.objects.get(slug=slug)
|
|
print(agency)
|
|
instance.agency = agency
|
|
instance.save()
|
|
return redirect("agency_portal_persons_list")
|
|
if view == "job":
|
|
return redirect("candidate_create")
|
|
return super().form_valid(form)
|
|
|
|
|
|
|
|
class PersonDetailView(DetailView):
|
|
model = Person
|
|
template_name = "people/person_detail.html"
|
|
context_object_name = "person"
|
|
|
|
|
|
class PersonUpdateView( UpdateView):
|
|
model = Person
|
|
template_name = "people/update_person.html"
|
|
form_class = PersonForm
|
|
success_url = reverse_lazy("person_list")
|
|
|
|
def form_valid(self, form):
|
|
if self.request.POST.get("view") == "portal":
|
|
form.save()
|
|
return redirect("agency_portal_persons_list")
|
|
return super().form_valid(form)
|
|
|
|
class PersonDeleteView(StaffRequiredMixin, DeleteView):
|
|
model = Person
|
|
template_name = "people/delete_person.html"
|
|
success_url = reverse_lazy("person_list")
|
|
|
|
|
|
class JobPostingViewSet(viewsets.ModelViewSet):
|
|
queryset = JobPosting.objects.all()
|
|
serializer_class = JobPostingSerializer
|
|
|
|
|
|
class CandidateViewSet(viewsets.ModelViewSet):
|
|
queryset = Application.objects.all()
|
|
serializer_class = ApplicationSerializer
|
|
|
|
|
|
class ZoomMeetingCreateView(StaffRequiredMixin, CreateView):
|
|
model = ZoomMeetingDetails
|
|
template_name = "meetings/create_meeting.html"
|
|
form_class = ZoomMeetingForm
|
|
success_url = "/"
|
|
|
|
def form_valid(self, form):
|
|
instance = form.save(commit=False)
|
|
try:
|
|
topic = instance.topic
|
|
if instance.start_time < timezone.now():
|
|
messages.error(self.request, "Start time must be in the future.")
|
|
return redirect(
|
|
reverse("create_meeting", kwargs={"slug": instance.slug})
|
|
)
|
|
start_time = instance.start_time
|
|
duration = instance.duration
|
|
|
|
result = create_zoom_meeting(topic, start_time, duration)
|
|
if result["status"] == "success":
|
|
instance.meeting_id = result["meeting_details"]["meeting_id"]
|
|
instance.join_url = result["meeting_details"]["join_url"]
|
|
instance.host_email = result["meeting_details"]["host_email"]
|
|
instance.password = result["meeting_details"]["password"]
|
|
instance.status = result["zoom_gateway_response"]["status"]
|
|
instance.zoom_gateway_response = result["zoom_gateway_response"]
|
|
instance.save()
|
|
messages.success(self.request, result["message"])
|
|
|
|
return redirect(reverse("list_meetings"))
|
|
else:
|
|
messages.error(self.request, result["message"])
|
|
return redirect(
|
|
reverse("create_meeting", kwargs={"slug": instance.slug})
|
|
)
|
|
except Exception as e:
|
|
messages.error(self.request, f"Error creating meeting: {e}")
|
|
return redirect(reverse("create_meeting", kwargs={"slug": instance.slug}))
|
|
|
|
|
|
|
|
class ZoomMeetingDetailsView(StaffRequiredMixin, DetailView):
|
|
model = ZoomMeetingDetails
|
|
template_name = "meetings/meeting_details.html"
|
|
context_object_name = "meeting"
|
|
|
|
def get_context_data(self, **kwargs):
|
|
context = super().get_context_data(**kwargs)
|
|
meeting = self.object
|
|
try:
|
|
interview = meeting.interview
|
|
except Exception as e:
|
|
print(e)
|
|
candidate = interview.candidate
|
|
job = meeting.get_job
|
|
|
|
# Assuming interview.participants and interview.system_users hold the people:
|
|
participants = list(interview.participants.all()) + list(
|
|
interview.system_users.all()
|
|
)
|
|
external_participants = list(interview.participants.all())
|
|
system_participants = list(interview.system_users.all())
|
|
total_participants = len(participants)
|
|
form = InterviewParticpantsForm(instance=interview)
|
|
context["form"] = form
|
|
context["email_form"] = InterviewEmailForm(
|
|
candidate=candidate,
|
|
external_participants=external_participants,
|
|
system_participants=system_participants,
|
|
meeting=meeting,
|
|
job=job,
|
|
)
|
|
context["total_participants"] = total_participants
|
|
return context
|
|
|
|
|
|
class ZoomMeetingUpdateView(StaffRequiredMixin, UpdateView):
|
|
model = ZoomMeetingDetails
|
|
form_class = ZoomMeetingForm
|
|
context_object_name = "meeting"
|
|
template_name = "meetings/update_meeting.html"
|
|
success_url = "/"
|
|
|
|
def get_form_kwargs(self):
|
|
kwargs = super().get_form_kwargs()
|
|
# Ensure the form is initialized with the instance's current values
|
|
if self.object:
|
|
kwargs['initial'] = getattr(kwargs, 'initial', {})
|
|
initial_start_time = ""
|
|
if self.object.start_time:
|
|
try:
|
|
initial_start_time = self.object.start_time.strftime('%m-%d-%Y,T%H:%M')
|
|
except AttributeError:
|
|
print(f"Warning: start_time {self.object.start_time} is not a datetime object.")
|
|
initial_start_time = ""
|
|
kwargs['initial']['start_time'] = initial_start_time
|
|
return kwargs
|
|
|
|
def form_valid(self, form):
|
|
instance = form.save(commit=False)
|
|
updated_data = {
|
|
"topic": instance.topic,
|
|
"start_time": instance.start_time.isoformat() + "Z",
|
|
"duration": instance.duration,
|
|
}
|
|
if instance.start_time < timezone.now():
|
|
messages.error(self.request, "Start time must be in the future.")
|
|
return redirect(reverse("meeting_details", kwargs={"slug": instance.slug}))
|
|
|
|
result = update_meeting(instance, updated_data)
|
|
|
|
if result["status"] == "success":
|
|
messages.success(self.request, result["message"])
|
|
else:
|
|
messages.error(self.request, result["message"])
|
|
return redirect(reverse("meeting_details", kwargs={"slug": instance.slug}))
|
|
|
|
|
|
def ZoomMeetingDeleteView(request, slug):
|
|
meeting = get_object_or_404(ZoomMeetingDetails, slug=slug)
|
|
if "HX-Request" in request.headers:
|
|
return render(
|
|
request,
|
|
"meetings/delete_meeting_form.html",
|
|
{
|
|
"meeting": meeting,
|
|
"delete_url": reverse("delete_meeting", kwargs={"slug": meeting.slug}),
|
|
},
|
|
)
|
|
if request.method == "POST":
|
|
try:
|
|
result = delete_zoom_meeting(meeting.meeting_id)
|
|
if (
|
|
result["status"] == "success"
|
|
or "Meeting does not exist" in result["details"]["message"]
|
|
):
|
|
meeting.delete()
|
|
messages.success(request, "Meeting deleted successfully.")
|
|
else:
|
|
messages.error(
|
|
request, f"{result['message']} , {result['details']['message']}"
|
|
)
|
|
return redirect(reverse("list_meetings"))
|
|
except Exception as e:
|
|
messages.error(request, str(e))
|
|
return redirect(reverse("list_meetings"))
|
|
|
|
# Job Posting
|
|
# def job_list(request):
|
|
# """Display the list of job postings order by creation date descending"""
|
|
# jobs=JobPosting.objects.all().order_by('-created_at')
|
|
|
|
# # Filter by status if provided
|
|
# print(f"the request is: {request} ")
|
|
# status=request.GET.get('status')
|
|
# print(f"DEBUG: Status filter received: {status}")
|
|
# if status:
|
|
# jobs=jobs.filter(status=status)
|
|
|
|
# #pagination
|
|
# paginator=Paginator(jobs,10) # Show 10 jobs per page
|
|
# page_number=request.GET.get('page')
|
|
# page_obj=paginator.get_page(page_number)
|
|
# return render(request, 'jobs/job_list.html', {
|
|
# 'page_obj': page_obj,
|
|
# 'status_filter': status
|
|
# })
|
|
|
|
|
|
@login_required
|
|
@staff_user_required
|
|
def create_job(request):
|
|
"""Create a new job posting"""
|
|
|
|
if request.method == "POST":
|
|
form = JobPostingForm(request.POST)
|
|
# to check user is authenticated or not
|
|
if form.is_valid():
|
|
try:
|
|
job = form.save(commit=False)
|
|
job.save()
|
|
job_apply_url_relative = reverse(
|
|
"application_detail", kwargs={"slug": job.slug}
|
|
)
|
|
job_apply_url_absolute = request.build_absolute_uri(
|
|
job_apply_url_relative
|
|
)
|
|
job.application_url = job_apply_url_absolute
|
|
# FormTemplate.objects.create(job=job, is_active=False, name=job.title,created_by=request.user)
|
|
job.save()
|
|
messages.success(request, f'Job "{job.title}" created successfully!')
|
|
return redirect("job_list")
|
|
except Exception as e:
|
|
logger.error(f"Error creating job: {e}")
|
|
messages.error(request, f"Error creating job: {e}")
|
|
else:
|
|
messages.error(request, f"Please correct the errors below.{form.errors}")
|
|
else:
|
|
form = JobPostingForm()
|
|
return render(request, "jobs/create_job.html", {"form": form})
|
|
|
|
|
|
@login_required
|
|
@staff_user_required
|
|
def edit_job(request, slug):
|
|
"""Edit an existing job posting"""
|
|
job = get_object_or_404(JobPosting, slug=slug)
|
|
if request.method == "POST":
|
|
form = JobPostingForm(request.POST, instance=job)
|
|
if form.is_valid():
|
|
try:
|
|
form.save()
|
|
messages.success(request, f'Job "{job.title}" updated successfully!')
|
|
return redirect("job_list")
|
|
except Exception as e:
|
|
logger.error(f"Error updating job: {e}")
|
|
messages.error(request, f"Error updating job: {e}")
|
|
else:
|
|
messages.error(request, "Please correct the errors below.")
|
|
else:
|
|
job = get_object_or_404(JobPosting, slug=slug)
|
|
form = JobPostingForm(instance=job)
|
|
return render(request, "jobs/edit_job.html", {"form": form, "job": job})
|
|
|
|
|
|
SCORE_PATH = "ai_analysis_data__analysis_data__match_score"
|
|
HIGH_POTENTIAL_THRESHOLD = 75
|
|
from django.contrib.sites.shortcuts import get_current_site
|
|
|
|
|
|
@staff_user_required
|
|
def job_detail(request, slug):
|
|
"""View details of a specific job"""
|
|
job = get_object_or_404(JobPosting, slug=slug)
|
|
# Get all applications for this job, ordered by most recent
|
|
applicants = job.applications.all().order_by("-created_at")
|
|
|
|
# Count applications by stage for summary statistics
|
|
total_applicant = applicants.count()
|
|
|
|
applied_count = applicants.filter(stage="Applied").count()
|
|
|
|
exam_count = applicants.filter(stage="Exam").count()
|
|
|
|
interview_count = applicants.filter(stage="Interview").count()
|
|
|
|
offer_count = applicants.filter(stage="Offer").count()
|
|
|
|
status_form = JobPostingStatusForm(instance=job)
|
|
linkedin_content_form = LinkedPostContentForm(instance=job)
|
|
try:
|
|
# If the related object exists, use its instance data
|
|
image_upload_form = JobPostingImageForm(instance=job.post_images)
|
|
except Exception as e:
|
|
# If the related object does NOT exist, create a blank form
|
|
image_upload_form = JobPostingImageForm()
|
|
|
|
# 2. Check for POST request (Status Update Submission)
|
|
if request.method == "POST":
|
|
status_form = JobPostingStatusForm(request.POST, instance=job)
|
|
|
|
if status_form.is_valid():
|
|
job_status = status_form.cleaned_data["status"]
|
|
form_template = job.form_template
|
|
if job_status == "ACTIVE":
|
|
form_template.is_active = True
|
|
form_template.save(update_fields=["is_active"])
|
|
else:
|
|
form_template.is_active = False
|
|
form_template.save(update_fields=["is_active"])
|
|
|
|
status_form.save()
|
|
|
|
# Add a success message
|
|
messages.success(
|
|
request,
|
|
f"Status for '{job.title}' updated to '{job.get_status_display()}' successfully!",
|
|
)
|
|
|
|
return redirect("job_detail", slug=slug)
|
|
else:
|
|
messages.error(request, "Failed to update status due to validation errors.")
|
|
|
|
# --- 2. Quality Metrics (JSON Aggregation) ---
|
|
|
|
|
|
|
|
candidates_with_score = applicants.filter(is_resume_parsed=True).annotate(
|
|
annotated_match_score=Coalesce(Cast(SCORE_PATH, output_field=IntegerField()), 0)
|
|
)
|
|
|
|
total_candidates = applicants.count()
|
|
avg_match_score_result = candidates_with_score.aggregate(
|
|
avg_score=Avg("annotated_match_score")
|
|
)["avg_score"]
|
|
avg_match_score = round(avg_match_score_result or 0, 1)
|
|
high_potential_count = candidates_with_score.filter(
|
|
annotated_match_score__gte=HIGH_POTENTIAL_THRESHOLD
|
|
).count()
|
|
high_potential_ratio = (
|
|
round((high_potential_count / total_candidates) * 100, 1)
|
|
if total_candidates > 0
|
|
else 0
|
|
)
|
|
|
|
# --- 3. Time Metrics (Duration Aggregation) ---
|
|
|
|
# Metric: Average Time from Applied to Interview (T2I)
|
|
t2i_candidates = applicants.filter(interview_date__isnull=False).annotate(
|
|
time_to_interview=ExpressionWrapper(
|
|
F("interview_date") - F("created_at"), output_field=DurationField()
|
|
)
|
|
)
|
|
avg_t2i_duration = t2i_candidates.aggregate(avg_t2i=Avg("time_to_interview"))[
|
|
"avg_t2i"
|
|
]
|
|
|
|
# Convert timedelta to days
|
|
avg_t2i_days = (
|
|
round(avg_t2i_duration.total_seconds() / (60 * 60 * 24), 1)
|
|
if avg_t2i_duration
|
|
else 0
|
|
)
|
|
|
|
# Metric: Average Time in Exam Stage
|
|
t_in_exam_candidates = applicants.filter(
|
|
exam_date__isnull=False, interview_date__isnull=False
|
|
).annotate(
|
|
time_in_exam=ExpressionWrapper(
|
|
F("interview_date") - F("exam_date"), output_field=DurationField()
|
|
)
|
|
)
|
|
avg_t_in_exam_duration = t_in_exam_candidates.aggregate(
|
|
avg_t_in_exam=Avg("time_in_exam")
|
|
)["avg_t_in_exam"]
|
|
|
|
# Convert timedelta to days
|
|
avg_t_in_exam_days = (
|
|
round(avg_t_in_exam_duration.total_seconds() / (60 * 60 * 24), 1)
|
|
if avg_t_in_exam_duration
|
|
else 0
|
|
)
|
|
|
|
category_data = (
|
|
applicants.filter(ai_analysis_data__analysis_data__category__isnull=False)
|
|
.values("ai_analysis_data__analysis_data__category")
|
|
.annotate(
|
|
candidate_count=Count("id"),
|
|
category=Cast(
|
|
"ai_analysis_data__analysis_data__category", output_field=CharField()
|
|
),
|
|
)
|
|
.order_by("ai_analysis_data__analysis_data__category")
|
|
)
|
|
# Prepare data for Chart.js
|
|
print(category_data)
|
|
categories = [item["category"] for item in category_data]
|
|
candidate_counts = [item["candidate_count"] for item in category_data]
|
|
# avg_scores = [round(item['avg_match_score'], 2) if item['avg_match_score'] is not None else 0 for item in category_data]
|
|
|
|
context = {
|
|
"job": job,
|
|
"applicants": applicants,
|
|
"total_applicants": total_applicant, # This was total_candidates in the prompt, using total_applicant for consistency
|
|
"applied_count": applied_count,
|
|
"exam_count": exam_count,
|
|
"interview_count": interview_count,
|
|
"offer_count": offer_count,
|
|
"status_form": status_form,
|
|
"image_upload_form": image_upload_form,
|
|
"categories": categories,
|
|
"candidate_counts": candidate_counts,
|
|
# 'avg_scores': avg_scores,
|
|
# New statistics
|
|
"avg_match_score": avg_match_score,
|
|
"high_potential_count": high_potential_count,
|
|
"high_potential_ratio": high_potential_ratio,
|
|
"avg_t2i_days": avg_t2i_days,
|
|
"avg_t_in_exam_days": avg_t_in_exam_days,
|
|
"linkedin_content_form": linkedin_content_form,
|
|
"staff_form": StaffAssignmentForm(),
|
|
}
|
|
return render(request, "jobs/job_detail.html", context)
|
|
|
|
|
|
# ALLOWED_EXTENSIONS = (".pdf", ".docx")
|
|
|
|
|
|
# def job_cvs_download(request, slug):
|
|
# job = get_object_or_404(JobPosting, slug=slug)
|
|
# entries = Application.objects.filter(job=job)
|
|
|
|
# # 2. Create an in-memory byte stream (BytesIO)
|
|
# zip_buffer = io.BytesIO()
|
|
|
|
# # 3. Create the ZIP archive
|
|
# with zipfile.ZipFile(zip_buffer, "w", zipfile.ZIP_DEFLATED) as zf:
|
|
# for entry in entries:
|
|
# # Check if the file field has a file
|
|
# if not entry.resume:
|
|
# continue
|
|
|
|
# # Get the file name and check extension (case-insensitive)
|
|
# file_name = entry.resume.name.split("/")[-1]
|
|
# file_name_lower = file_name.lower()
|
|
|
|
# if file_name_lower.endswith(ALLOWED_EXTENSIONS):
|
|
# try:
|
|
# # Open the file object (rb is read binary)
|
|
# file_obj = entry.resume.open("rb")
|
|
|
|
# # *** ROBUST METHOD: Read the content and write it to the ZIP ***
|
|
# file_content = file_obj.read()
|
|
|
|
# # Write the file content directly to the ZIP archive
|
|
# zf.writestr(file_name, file_content)
|
|
|
|
# file_obj.close()
|
|
|
|
# except Exception as e:
|
|
# # Log the error but continue with the rest of the files
|
|
# print(f"Error processing file {file_name}: {e}")
|
|
# continue
|
|
|
|
# # 4. Prepare the response
|
|
# zip_buffer.seek(0)
|
|
|
|
# # 5. Create the HTTP response
|
|
# response = HttpResponse(zip_buffer.read(), content_type="application/zip")
|
|
|
|
# # Set the header for the browser to download the file
|
|
# response["Content-Disposition"] = (
|
|
# f'attachment; filename="all_cvs_for_{job.title}.zip"'
|
|
# )
|
|
|
|
# return response
|
|
|
|
def request_cvs_download(request, slug):
|
|
"""
|
|
View to initiate the background task.
|
|
"""
|
|
job = get_object_or_404(JobPosting, slug=slug)
|
|
job.zip_created = False
|
|
job.save(update_fields=["zip_created"])
|
|
# Use async_task to run the function in the background
|
|
# Pass only simple arguments (like the job ID)
|
|
async_task('recruitment.tasks.generate_and_save_cv_zip', job.id)
|
|
|
|
# Provide user feedback and redirect
|
|
messages.info(request, "The CV compilation has started in the background. It may take a few moments. Refresh this page to check status.")
|
|
return redirect('job_detail', slug=slug) # Redirect back to the job detail page
|
|
|
|
def download_ready_cvs(request, slug):
|
|
"""
|
|
View to serve the file once it is ready.
|
|
"""
|
|
job = get_object_or_404(JobPosting, slug=slug)
|
|
|
|
if job.cv_zip_file and job.zip_created:
|
|
# Django FileField handles the HttpResponse and file serving easily
|
|
response = HttpResponse(job.cv_zip_file.read(), content_type="application/zip")
|
|
response["Content-Disposition"] = f'attachment; filename="{job.cv_zip_file.name.split("/")[-1]}"'
|
|
return response
|
|
else:
|
|
# File is not ready or doesn't exist
|
|
messages.warning(request, "The ZIP file is still being generated or an error occurred.")
|
|
return redirect('job_detail', slug=slug)
|
|
|
|
@login_required
|
|
@staff_user_required
|
|
def job_image_upload(request, slug):
|
|
# only for handling the post request
|
|
job = get_object_or_404(JobPosting, slug=slug)
|
|
try:
|
|
instance = JobPostingImage.objects.get(job=job)
|
|
except JobPostingImage.DoesNotExist:
|
|
# If it doesn't exist, create a new instance placeholder
|
|
instance = None
|
|
|
|
if request.method == "POST":
|
|
# Pass the existing instance to the form if it exists
|
|
image_upload_form = JobPostingImageForm(
|
|
request.POST, request.FILES, instance=instance
|
|
)
|
|
|
|
if image_upload_form.is_valid():
|
|
# If creating a new one (instance is None), set the job link manually
|
|
if instance is None:
|
|
image_instance = image_upload_form.save(commit=False)
|
|
image_instance.job = job
|
|
image_instance.save()
|
|
messages.success(
|
|
request, f"Image uploaded successfully for {job.title}."
|
|
)
|
|
else:
|
|
# If updating, the form will update the instance passed to it
|
|
image_upload_form.save()
|
|
messages.success(
|
|
request, f"Image updated successfully for {job.title}."
|
|
)
|
|
|
|
else:
|
|
messages.error(
|
|
request,
|
|
"Image upload failed: Please ensure a valid image file was selected.",
|
|
)
|
|
return redirect("job_detail", slug=job.slug)
|
|
return redirect("job_detail", slug=job.slug)
|
|
|
|
|
|
@login_required
|
|
@staff_user_required
|
|
def edit_linkedin_post_content(request, slug):
|
|
job = get_object_or_404(JobPosting, slug=slug)
|
|
linkedin_content_form = LinkedPostContentForm(instance=job)
|
|
if request.method == "POST":
|
|
linkedin_content_form = LinkedPostContentForm(request.POST, instance=job)
|
|
if linkedin_content_form.is_valid():
|
|
linkedin_content_form.save()
|
|
messages.success(request, "Linked post content updated successfully!")
|
|
return redirect("job_detail", job.slug)
|
|
else:
|
|
messages.error(request, "Error update the Linkedin Post content")
|
|
return redirect("job_detail", job.slug)
|
|
|
|
else:
|
|
linkedin_content_form = LinkedPostContentForm()
|
|
return redirect("job_detail", job.slug)
|
|
|
|
|
|
JOB_TYPES = [
|
|
("FULL_TIME", "Full-time"),
|
|
("PART_TIME", "Part-time"),
|
|
("CONTRACT", "Contract"),
|
|
("INTERNSHIP", "Internship"),
|
|
("FACULTY", "Faculty"),
|
|
("TEMPORARY", "Temporary"),
|
|
]
|
|
|
|
WORKPLACE_TYPES = [
|
|
("ON_SITE", "On-site"),
|
|
("REMOTE", "Remote"),
|
|
("HYBRID", "Hybrid"),
|
|
]
|
|
|
|
|
|
def kaauh_career(request):
|
|
active_jobs = JobPosting.objects.select_related("form_template").filter(
|
|
status="ACTIVE", form_template__is_active=True
|
|
)
|
|
selected_department = request.GET.get("department", "")
|
|
department_type_keys = (
|
|
active_jobs.exclude(department__isnull=True)
|
|
.exclude(department__exact="")
|
|
.values_list("department", flat=True)
|
|
.distinct()
|
|
.order_by("department")
|
|
)
|
|
|
|
if selected_department and selected_department in department_type_keys:
|
|
active_jobs = active_jobs.filter(department=selected_department)
|
|
selected_workplace_type = request.GET.get("workplace_type", "")
|
|
|
|
selected_job_type = request.GET.get("employment_type", "")
|
|
|
|
job_type_keys = active_jobs.order_by("job_type").distinct("job_type").values_list("job_type", flat=True)
|
|
print(job_type_keys)
|
|
workplace_type_keys = active_jobs.order_by("workplace_type").distinct("workplace_type").values_list(
|
|
"workplace_type", flat=True
|
|
).distinct()
|
|
print(workplace_type_keys)
|
|
if selected_job_type and selected_job_type in job_type_keys:
|
|
active_jobs = active_jobs.filter(job_type=selected_job_type)
|
|
if selected_workplace_type and selected_workplace_type in workplace_type_keys:
|
|
active_jobs = active_jobs.filter(workplace_type=selected_workplace_type)
|
|
|
|
JOBS_PER_PAGE = 10
|
|
paginator = Paginator(active_jobs, JOBS_PER_PAGE)
|
|
page_number = request.GET.get("page", 1)
|
|
|
|
try:
|
|
page_obj = paginator.get_page(page_number)
|
|
except EmptyPage:
|
|
page_obj = paginator.page(paginator.num_pages)
|
|
|
|
total_open_roles = active_jobs.all().count()
|
|
|
|
return render(
|
|
request,
|
|
"applicant/career.html",
|
|
{
|
|
"active_jobs": page_obj.object_list,
|
|
"job_type_keys": job_type_keys,
|
|
"selected_job_type": selected_job_type,
|
|
"workplace_type_keys": workplace_type_keys,
|
|
"selected_workplace_type": selected_workplace_type,
|
|
"selected_department": selected_department,
|
|
"department_type_keys": department_type_keys,
|
|
"total_open_roles": total_open_roles,
|
|
"page_obj": page_obj,
|
|
},
|
|
)
|
|
|
|
|
|
# job detail facing the candidate:
|
|
def application_detail(request, slug):
|
|
job = get_object_or_404(JobPosting, slug=slug)
|
|
return render(request, "applicant/application_detail.html", {"job": job})
|
|
|
|
|
|
@login_required
|
|
@staff_user_required
|
|
def post_to_linkedin(request, slug):
|
|
"""Post a job to LinkedIn"""
|
|
job = get_object_or_404(JobPosting, slug=slug)
|
|
if job.status != "ACTIVE":
|
|
messages.info(request, "Only active jobs can be posted to LinkedIn.")
|
|
return redirect("job_list")
|
|
|
|
if request.method == "POST":
|
|
linkedin_access_token = request.session.get("linkedin_access_token")
|
|
# Check if user is authenticated with LinkedIn
|
|
if not "linkedin_access_token":
|
|
messages.error(request, "Please authenticate with LinkedIn first.")
|
|
return redirect("linkedin_login")
|
|
try:
|
|
# Clear previous LinkedIn data for re-posting
|
|
# Prepare the job object for background processing
|
|
job.posted_to_linkedin = False
|
|
job.linkedin_post_id = ""
|
|
job.linkedin_post_url = ""
|
|
job.linkedin_post_status = "QUEUED"
|
|
job.linkedin_posted_at = None
|
|
job.save()
|
|
|
|
# ENQUEUE THE TASK
|
|
# Pass the function path, the job slug, and the token as arguments
|
|
|
|
async_task(
|
|
"recruitment.tasks.linkedin_post_task", job.slug, linkedin_access_token
|
|
)
|
|
|
|
messages.success(
|
|
request,
|
|
_(
|
|
f"✅ Job posting process for job with JOB ID: {job.internal_job_id} started! Check the job details page in a moment for the final status."
|
|
),
|
|
)
|
|
|
|
except Exception as e:
|
|
logger.error(f"Error enqueuing LinkedIn post: {e}")
|
|
messages.error(
|
|
request, _("Failed to start the job posting process. Please try again.")
|
|
)
|
|
|
|
return redirect("job_detail", slug=job.slug)
|
|
|
|
|
|
def linkedin_login(request):
|
|
"""Redirect to LinkedIn OAuth"""
|
|
service = LinkedInService()
|
|
auth_url = service.get_auth_url()
|
|
"""
|
|
It creates a special URL that:
|
|
Sends the user to LinkedIn to log in
|
|
Asks the user to grant your app permission to post on their behalf
|
|
Tells LinkedIn where to send the user back after they approve (your redirect_uri)
|
|
http://yoursite.com/linkedin/callback/?code=TEMPORARY_CODE_HERE
|
|
"""
|
|
return redirect(auth_url)
|
|
|
|
|
|
def linkedin_callback(request):
|
|
"""Handle LinkedIn OAuth callback"""
|
|
code = request.GET.get("code")
|
|
if not code:
|
|
messages.error(request, "No authorization code received from LinkedIn.")
|
|
return redirect("job_list")
|
|
|
|
try:
|
|
service = LinkedInService()
|
|
# get_access_token(code)->It makes a POST request to LinkedIn's token endpoint with parameters
|
|
access_token = service.get_access_token(code)
|
|
request.session["linkedin_access_token"] = access_token
|
|
request.session["linkedin_authenticated"] = True
|
|
settings.LINKEDIN_IS_CONNECTED = True
|
|
messages.success(request, "Successfully authenticated with LinkedIn!")
|
|
except Exception as e:
|
|
logger.error(f"LinkedIn authentication error: {e}")
|
|
messages.error(request, f"LinkedIn authentication failed: {e}")
|
|
|
|
return redirect("job_list")
|
|
|
|
|
|
# applicant views
|
|
def applicant_job_detail(request, slug):
|
|
"""View job details for applicants"""
|
|
job = get_object_or_404(JobPosting, slug=slug, status="ACTIVE")
|
|
return render(request, "jobs/applicant_job_detail.html", {"job": job})
|
|
|
|
|
|
def application_success(request, slug):
|
|
job = get_object_or_404(JobPosting, slug=slug)
|
|
return render(request, "jobs/application_success.html", {"job": job})
|
|
|
|
|
|
@ensure_csrf_cookie
|
|
@login_required
|
|
@staff_user_required
|
|
def form_builder(request, template_slug=None):
|
|
"""Render the form builder interface"""
|
|
context = {}
|
|
if template_slug:
|
|
template = get_object_or_404(FormTemplate, slug=template_slug)
|
|
context["template"] = template
|
|
context["template_slug"] = template.slug
|
|
context["template_name"] = template.name
|
|
return render(request, "forms/form_builder.html", context)
|
|
|
|
|
|
@csrf_exempt
|
|
@require_http_methods(["POST"])
|
|
def save_form_template(request):
|
|
"""Save a new or existing form template"""
|
|
try:
|
|
data = json.loads(request.body)
|
|
template_name = data.get("name", "Untitled Form")
|
|
stages_data = data.get("stages", [])
|
|
template_slug = data.get("template_slug")
|
|
|
|
if template_slug:
|
|
# Update existing template
|
|
template = get_object_or_404(FormTemplate, slug=template_slug)
|
|
template.name = template_name
|
|
template.save()
|
|
# Clear existing stages and fields
|
|
template.stages.all().delete()
|
|
else:
|
|
# Create new template
|
|
template = FormTemplate.objects.create(name=template_name)
|
|
|
|
# Create stages and fields
|
|
for stage_order, stage_data in enumerate(stages_data):
|
|
stage = FormStage.objects.create(
|
|
template=template,
|
|
name=stage_data["name"],
|
|
order=stage_order,
|
|
is_predefined=stage_data.get("predefined", False),
|
|
)
|
|
|
|
for field_order, field_data in enumerate(stage_data["fields"]):
|
|
options = field_data.get("options", [])
|
|
if not isinstance(options, list):
|
|
options = []
|
|
|
|
file_types = field_data.get("fileTypes", "")
|
|
max_file_size = field_data.get("maxFileSize", 5)
|
|
|
|
FormField.objects.create(
|
|
stage=stage,
|
|
label=field_data.get("label", ""),
|
|
field_type=field_data.get("type", "text"),
|
|
placeholder=field_data.get("placeholder", ""),
|
|
required=field_data.get("required", False),
|
|
order=field_order,
|
|
is_predefined=field_data.get("predefined", False),
|
|
options=options,
|
|
file_types=file_types,
|
|
max_file_size=max_file_size,
|
|
)
|
|
|
|
return JsonResponse(
|
|
{
|
|
"success": True,
|
|
"template_slug": template.slug,
|
|
"message": "Form template saved successfully!",
|
|
}
|
|
)
|
|
except Exception as e:
|
|
return JsonResponse({"success": False, "error": str(e)}, status=400)
|
|
|
|
|
|
@require_http_methods(["GET"])
|
|
def load_form_template(request, template_slug):
|
|
"""Load an existing form template"""
|
|
template = get_object_or_404(FormTemplate, slug=template_slug)
|
|
|
|
stages = []
|
|
for stage in template.stages.all():
|
|
fields = []
|
|
for field in stage.fields.all():
|
|
fields.append(
|
|
{
|
|
"id": field.id,
|
|
"type": field.field_type,
|
|
"label": field.label,
|
|
"placeholder": field.placeholder,
|
|
"required": field.required,
|
|
"options": field.options,
|
|
"fileTypes": field.file_types,
|
|
"maxFileSize": field.max_file_size,
|
|
"predefined": field.is_predefined,
|
|
}
|
|
)
|
|
stages.append(
|
|
{
|
|
"id": stage.id,
|
|
"name": stage.name,
|
|
"predefined": stage.is_predefined,
|
|
"fields": fields,
|
|
}
|
|
)
|
|
|
|
return JsonResponse(
|
|
{
|
|
"success": True,
|
|
"template": {
|
|
"id": template.id,
|
|
"template_slug": template.slug,
|
|
"name": template.name,
|
|
"description": template.description,
|
|
"is_active": template.is_active,
|
|
"job": template.job_id if template.job else None,
|
|
"stages": stages,
|
|
},
|
|
}
|
|
)
|
|
|
|
|
|
@login_required
|
|
@staff_user_required
|
|
def form_templates_list(request):
|
|
"""List all form templates for the current user"""
|
|
query = request.GET.get("q", "")
|
|
templates = FormTemplate.objects.filter()
|
|
|
|
if query:
|
|
templates = templates.filter(
|
|
Q(name__icontains=query) | Q(description__icontains=query)
|
|
)
|
|
|
|
templates = templates.order_by("-created_at")
|
|
paginator = Paginator(templates, 10) # Show 10 templates per page
|
|
page_number = request.GET.get("page")
|
|
page_obj = paginator.get_page(page_number)
|
|
form = FormTemplateForm()
|
|
form.fields["job"].queryset = JobPosting.objects.filter(form_template__isnull=True)
|
|
context = {"templates": page_obj, "query": query, "form": form}
|
|
return render(request, "forms/form_templates_list.html", context)
|
|
|
|
|
|
@login_required
|
|
@staff_user_required
|
|
def create_form_template(request):
|
|
"""Create a new form template"""
|
|
if request.method == "POST":
|
|
form = FormTemplateForm(request.POST)
|
|
if form.is_valid():
|
|
template = form.save(commit=False)
|
|
template.created_by = request.user
|
|
template.save()
|
|
messages.success(
|
|
request, f'Form template "{template.name}" created successfully!'
|
|
)
|
|
return redirect("form_templates_list")
|
|
else:
|
|
form = FormTemplateForm()
|
|
|
|
return render(request, "forms/create_form_template.html", {"form": form})
|
|
|
|
|
|
@login_required
|
|
@staff_user_required
|
|
@require_http_methods(["GET"])
|
|
def list_form_templates(request):
|
|
"""List all form templates for the current user"""
|
|
templates = FormTemplate.objects.filter().values(
|
|
"id", "name", "description", "created_at", "updated_at"
|
|
)
|
|
return JsonResponse({"success": True, "templates": list(templates)})
|
|
|
|
|
|
@login_required
|
|
@staff_user_required
|
|
def form_submission_details(request, template_id, slug):
|
|
"""Display detailed view of a specific form submission"""
|
|
# Get form template and verify ownership
|
|
template = get_object_or_404(FormTemplate, id=template_id)
|
|
# Get the specific submission
|
|
submission = get_object_or_404(FormSubmission, slug=slug, template=template)
|
|
|
|
# Get all stages with their fields
|
|
stages = template.stages.prefetch_related("fields").order_by("order")
|
|
|
|
# Get all responses for this submission, ordered by field order
|
|
responses = submission.responses.select_related("field").order_by("field__order")
|
|
|
|
# Group responses by stage
|
|
stage_responses = {}
|
|
for stage in stages:
|
|
stage_responses[stage.id] = {
|
|
"stage": stage,
|
|
"responses": responses.filter(field__stage=stage),
|
|
}
|
|
|
|
return render(
|
|
request,
|
|
"forms/form_submission_details.html",
|
|
{
|
|
"template": template,
|
|
"submission": submission,
|
|
"stages": stages,
|
|
"responses": responses,
|
|
"stage_responses": stage_responses,
|
|
},
|
|
)
|
|
# return redirect("application_detail", slug=job.slug)
|
|
|
|
# return render(
|
|
# request,
|
|
# "forms/application_submit_form.html",
|
|
# {"template_slug": template_slug, "job_id": job_id},
|
|
# )
|
|
|
|
|
|
@login_required
|
|
@staff_user_required
|
|
@require_http_methods(["DELETE"])
|
|
def delete_form_template(request, template_id):
|
|
"""Delete a form template"""
|
|
template = get_object_or_404(FormTemplate, id=template_id)
|
|
template.delete()
|
|
return JsonResponse(
|
|
{"success": True, "message": "Form template deleted successfully!"}
|
|
)
|
|
|
|
|
|
|
|
def application_submit_form(request, template_slug):
|
|
"""Display the form as a step-by-step wizard"""
|
|
if not request.user.is_authenticated:
|
|
return redirect("candidate_signup",slug=template_slug)
|
|
template = get_object_or_404(FormTemplate, slug=template_slug, is_active=True)
|
|
stage = template.stages.filter(name="Contact Information")
|
|
|
|
|
|
job_id = template.job.internal_job_id
|
|
job = template.job
|
|
is_limit_exceeded = job.is_application_limit_reached
|
|
if is_limit_exceeded:
|
|
messages.error(
|
|
request,
|
|
_(
|
|
"Application limit reached: This job is no longer accepting new applications."
|
|
),
|
|
)
|
|
return redirect("application_detail", slug=job.slug)
|
|
if job.is_expired:
|
|
messages.error(
|
|
request,
|
|
_(
|
|
"Application deadline passed: This job is no longer accepting new applications."
|
|
),
|
|
)
|
|
return redirect("application_detail", slug=job.slug)
|
|
|
|
return render(
|
|
request,
|
|
"applicant/application_submit_form.html",
|
|
{"template_slug": template_slug, "job_id": job_id},
|
|
)
|
|
|
|
|
|
# def applicant_profile(request):
|
|
# return render(request, "applicant/applicant_profile.html")
|
|
|
|
|
|
@csrf_exempt
|
|
@require_POST
|
|
def application_submit(request, template_slug):
|
|
"""Handle form submission"""
|
|
if not request.user.is_authenticated :# or request.user.user_type != "candidate":
|
|
return JsonResponse({"success": False, "message": "Unauthorized access."})
|
|
template = get_object_or_404(FormTemplate, slug=template_slug)
|
|
job = template.job
|
|
if request.method == "POST":
|
|
try:
|
|
with transaction.atomic():
|
|
job_posting = JobPosting.objects.select_for_update().get(
|
|
form_template=template
|
|
)
|
|
|
|
current_count = job_posting.applications.count()
|
|
if current_count >= job_posting.max_applications:
|
|
template.is_active = False
|
|
template.save()
|
|
return JsonResponse(
|
|
{
|
|
"success": False,
|
|
"message": "Application limit reached for this job.",
|
|
}
|
|
)
|
|
submission = FormSubmission.objects.create(template=template,submitted_by=request.user)
|
|
|
|
# Process field responses
|
|
for field_id, value in request.POST.items():
|
|
if field_id.startswith("field_"):
|
|
actual_field_id = field_id.replace("field_", "")
|
|
try:
|
|
field = FormField.objects.get(
|
|
id=actual_field_id, stage__template=template
|
|
)
|
|
FieldResponse.objects.create(
|
|
submission=submission,
|
|
field=field,
|
|
value=value if value else None,
|
|
)
|
|
except FormField.DoesNotExist:
|
|
continue
|
|
|
|
# Handle file uploads
|
|
for field_id, uploaded_file in request.FILES.items():
|
|
if field_id.startswith("field_"):
|
|
actual_field_id = field_id.replace("field_", "")
|
|
try:
|
|
field = FormField.objects.get(
|
|
id=actual_field_id, stage__template=template
|
|
)
|
|
FieldResponse.objects.create(
|
|
submission=submission,
|
|
field=field,
|
|
uploaded_file=uploaded_file,
|
|
)
|
|
except FormField.DoesNotExist:
|
|
continue
|
|
try:
|
|
# first_name = submission.responses.get(field__label="First Name")
|
|
# last_name = submission.responses.get(field__label="Last Name")
|
|
# email = submission.responses.get(field__label="Email Address")
|
|
# phone = submission.responses.get(field__label="Phone Number")
|
|
# address = submission.responses.get(field__label="Address")
|
|
gpa = submission.responses.get(field__label="GPA")
|
|
|
|
resume = submission.responses.get(field__label="Resume Upload")
|
|
|
|
submission.applicant_name = (
|
|
f"{request.user.first_name} {request.user.last_name}"
|
|
)
|
|
submission.applicant_email = request.user.email
|
|
submission.save()
|
|
# time=timezone.now()
|
|
person = request.user.person_profile
|
|
person.gpa = gpa.value if gpa else None
|
|
person.save()
|
|
Application.objects.create(
|
|
person = person,
|
|
resume=resume.get_file if resume.is_file else None,
|
|
job=job,
|
|
)
|
|
return JsonResponse(
|
|
{
|
|
"success": True,
|
|
"message": "Form submitted successfully!",
|
|
"redirect_url": reverse(
|
|
"application_success", kwargs={"slug": job.slug}
|
|
),
|
|
}
|
|
)
|
|
# return redirect('application_success',slug=job.slug)
|
|
|
|
except Exception as e:
|
|
logger.error(f"Candidate creation failed,{e}")
|
|
pass
|
|
return JsonResponse(
|
|
{
|
|
"success": True,
|
|
"message": "Form submitted successfully!",
|
|
"submission_id": submission.id,
|
|
}
|
|
)
|
|
except Exception as e:
|
|
return JsonResponse({"success": False, "error": str(e)}, status=400)
|
|
else:
|
|
# Handle GET request - this should not happen for form submission
|
|
return JsonResponse(
|
|
{"success": False, "error": "GET method not allowed for form submission"},
|
|
status=405,
|
|
)
|
|
|
|
|
|
@login_required
|
|
@staff_user_required
|
|
def form_template_submissions_list(request, slug):
|
|
"""List all submissions for a specific form template"""
|
|
template = get_object_or_404(FormTemplate, slug=slug)
|
|
|
|
submissions = FormSubmission.objects.filter(template=template).order_by(
|
|
"-submitted_at"
|
|
)
|
|
|
|
# Pagination
|
|
paginator = Paginator(submissions, 10) # Show 10 submissions per page
|
|
page_number = request.GET.get("page")
|
|
page_obj = paginator.get_page(page_number)
|
|
|
|
return render(
|
|
request,
|
|
"forms/form_template_submissions_list.html",
|
|
{"template": template, "page_obj": page_obj},
|
|
)
|
|
|
|
|
|
@login_required
|
|
@staff_user_required
|
|
def form_template_all_submissions(request, template_id):
|
|
"""Display all submissions for a form template in table format"""
|
|
template = get_object_or_404(FormTemplate, id=template_id)
|
|
print(template)
|
|
# Get all submissions for this template
|
|
submissions = FormSubmission.objects.filter(template=template).order_by(
|
|
"-submitted_at"
|
|
)
|
|
|
|
# Get all fields for this template, ordered by stage and field order
|
|
fields = (
|
|
FormField.objects.filter(stage__template=template)
|
|
.select_related("stage")
|
|
.order_by("stage__order", "order")
|
|
)
|
|
|
|
# Pagination
|
|
paginator = Paginator(submissions, 10) # Show 10 submissions per page
|
|
page_number = request.GET.get("page")
|
|
page_obj = paginator.get_page(page_number)
|
|
|
|
return render(
|
|
request,
|
|
"forms/form_template_all_submissions.html",
|
|
{
|
|
"template": template,
|
|
"page_obj": page_obj,
|
|
"fields": fields,
|
|
},
|
|
)
|
|
|
|
|
|
@login_required
|
|
def form_submission_details(request, template_id, slug):
|
|
"""Display detailed view of a specific form submission"""
|
|
# Get the form template and verify ownership
|
|
template = get_object_or_404(FormTemplate, id=template_id)
|
|
# Get the specific submission
|
|
submission = get_object_or_404(FormSubmission, slug=slug, template=template)
|
|
|
|
# Get all stages with their fields
|
|
stages = template.stages.prefetch_related("fields").order_by("order")
|
|
|
|
# Get all responses for this submission, ordered by field order
|
|
responses = submission.responses.select_related("field").order_by("field__order")
|
|
|
|
# Group responses by stage
|
|
stage_responses = {}
|
|
for stage in stages:
|
|
stage_responses[stage.id] = {
|
|
"stage": stage,
|
|
"responses": responses.filter(field__stage=stage),
|
|
}
|
|
|
|
return render(
|
|
request,
|
|
"forms/form_submission_details.html",
|
|
{
|
|
"template": template,
|
|
"submission": submission,
|
|
"stages": stages,
|
|
"responses": responses,
|
|
"stage_responses": stage_responses,
|
|
},
|
|
)
|
|
|
|
|
|
def _handle_get_request(request, slug, job):
|
|
"""
|
|
Handles GET requests, setting up forms and restoring candidate selections
|
|
from the session for persistence.
|
|
"""
|
|
SESSION_KEY = f"schedule_candidate_ids_{slug}"
|
|
|
|
form = InterviewScheduleForm(slug=slug)
|
|
# break_formset = BreakTimeFormSet(prefix='breaktime')
|
|
|
|
selected_ids = []
|
|
|
|
# 1. Capture IDs from HTMX request and store in session (when first clicked)
|
|
if "HX-Request" in request.headers:
|
|
candidate_ids = request.GET.getlist("candidate_ids")
|
|
|
|
if candidate_ids:
|
|
request.session[SESSION_KEY] = candidate_ids
|
|
selected_ids = candidate_ids
|
|
|
|
# 2. Restore IDs from session (on refresh or navigation)
|
|
if not selected_ids:
|
|
selected_ids = request.session.get(SESSION_KEY, [])
|
|
|
|
# 3. Use the list of IDs to initialize the form
|
|
if selected_ids:
|
|
candidates_to_load = Application.objects.filter(pk__in=selected_ids)
|
|
print(candidates_to_load)
|
|
form.initial["applications"] = candidates_to_load
|
|
|
|
return render(
|
|
request,
|
|
"interviews/schedule_interviews.html",
|
|
{"form": form, "job": job},
|
|
)
|
|
|
|
|
|
|
|
def _handle_preview_submission(request, slug, job):
|
|
"""
|
|
Handles the initial POST request (Preview Schedule).
|
|
Validates forms, calculates slots, saves data to session, and renders preview.
|
|
"""
|
|
SESSION_DATA_KEY = "interview_schedule_data"
|
|
form = InterviewScheduleForm(slug, request.POST)
|
|
# break_formset = BreakTimeFormSet(request.POST,prefix='breaktime')
|
|
|
|
if form.is_valid():
|
|
# Get the form data
|
|
applications = form.cleaned_data["applications"]
|
|
start_date = form.cleaned_data["start_date"]
|
|
end_date = form.cleaned_data["end_date"]
|
|
working_days = form.cleaned_data["working_days"]
|
|
start_time = form.cleaned_data["start_time"]
|
|
end_time = form.cleaned_data["end_time"]
|
|
interview_duration = form.cleaned_data["interview_duration"]
|
|
buffer_time = form.cleaned_data["buffer_time"]
|
|
break_start_time = form.cleaned_data["break_start_time"]
|
|
break_end_time = form.cleaned_data["break_end_time"]
|
|
schedule_interview_type=form.cleaned_data["schedule_interview_type"]
|
|
# Process break times
|
|
# breaks = []
|
|
# for break_form in break_formset:
|
|
# print(break_form.cleaned_data)
|
|
# if break_form.cleaned_data and not break_form.cleaned_data.get("DELETE"):
|
|
# breaks.append(
|
|
# {
|
|
# "start_time": break_form.cleaned_data["start_time"].strftime("%H:%M:%S"),
|
|
# "end_time": break_form.cleaned_data["end_time"].strftime("%H:%M:%S"),
|
|
# }
|
|
# )
|
|
|
|
# Create a temporary schedule object (not saved to DB)
|
|
temp_schedule = InterviewSchedule(
|
|
job=job,
|
|
start_date=start_date,
|
|
end_date=end_date,
|
|
working_days=working_days,
|
|
start_time=start_time,
|
|
end_time=end_time,
|
|
interview_duration=interview_duration,
|
|
buffer_time=buffer_time or 5,
|
|
break_start_time=break_start_time or None,
|
|
break_end_time=break_end_time or None,
|
|
)
|
|
|
|
# Get available slots (temp_breaks logic moved into get_available_time_slots if needed)
|
|
available_slots = get_available_time_slots(temp_schedule)
|
|
|
|
if len(available_slots) < len(applications):
|
|
messages.error(
|
|
request,
|
|
f"Not enough available slots. Required: {len(applications)}, Available: {len(available_slots)}",
|
|
)
|
|
return render(
|
|
request,
|
|
"interviews/schedule_interviews.html",
|
|
{"form": form, "job": job},
|
|
)
|
|
|
|
# Create a preview schedule
|
|
preview_schedule = []
|
|
for i, application in enumerate(applications):
|
|
slot = available_slots[i]
|
|
preview_schedule.append(
|
|
{"application": application, "date": slot["date"], "time": slot["time"]}
|
|
)
|
|
|
|
# Save the form data to session for later use
|
|
schedule_data = {
|
|
"start_date": start_date.isoformat(),
|
|
"end_date": end_date.isoformat(),
|
|
"working_days": working_days,
|
|
"start_time": start_time.isoformat(),
|
|
"end_time": end_time.isoformat(),
|
|
"interview_duration": interview_duration,
|
|
"buffer_time": buffer_time,
|
|
"break_start_time": break_start_time.isoformat() if break_start_time else None,
|
|
"break_end_time": break_end_time.isoformat() if break_end_time else None,
|
|
"candidate_ids": [c.id for c in applications],
|
|
"schedule_interview_type":schedule_interview_type
|
|
|
|
}
|
|
request.session[SESSION_DATA_KEY] = schedule_data
|
|
|
|
# Render the preview page
|
|
return render(
|
|
request,
|
|
"interviews/preview_schedule.html",
|
|
{
|
|
"job": job,
|
|
"schedule": preview_schedule,
|
|
"start_date": start_date,
|
|
"end_date": end_date,
|
|
"working_days": working_days,
|
|
"start_time": start_time,
|
|
"end_time": end_time,
|
|
"break_start_time": break_start_time,
|
|
"break_end_time": break_end_time,
|
|
"interview_duration": interview_duration,
|
|
"buffer_time": buffer_time,
|
|
"schedule_interview_type":schedule_interview_type,
|
|
"form":OnsiteLocationForm()
|
|
},
|
|
)
|
|
else:
|
|
# Re-render the form if validation fails
|
|
return render(
|
|
request,
|
|
"interviews/schedule_interviews.html",
|
|
{"form": form, "job": job},
|
|
)
|
|
|
|
|
|
|
|
def _handle_confirm_schedule(request, slug, job):
|
|
"""
|
|
Handles the final POST request (Confirm Schedule).
|
|
Creates the main schedule record and queues individual interviews asynchronously.
|
|
"""
|
|
|
|
SESSION_DATA_KEY = "interview_schedule_data"
|
|
SESSION_ID_KEY = f"schedule_candidate_ids_{slug}"
|
|
|
|
# 1. Get schedule data from session
|
|
schedule_data = request.session.get(SESSION_DATA_KEY)
|
|
|
|
if not schedule_data:
|
|
messages.error(request, "Session expired. Please try again.")
|
|
return redirect("schedule_interviews", slug=slug)
|
|
|
|
# 2. Create the Interview Schedule (Parent Record)
|
|
try:
|
|
# Handle break times: If they exist, convert them; otherwise, pass None.
|
|
break_start = schedule_data.get("break_start_time")
|
|
break_end = schedule_data.get("break_end_time")
|
|
|
|
schedule = InterviewSchedule.objects.create(
|
|
job=job,
|
|
created_by=request.user,
|
|
start_date=datetime.fromisoformat(schedule_data["start_date"]).date(),
|
|
end_date=datetime.fromisoformat(schedule_data["end_date"]).date(),
|
|
working_days=schedule_data["working_days"],
|
|
start_time=time.fromisoformat(schedule_data["start_time"]),
|
|
end_time=time.fromisoformat(schedule_data["end_time"]),
|
|
interview_duration=schedule_data["interview_duration"],
|
|
buffer_time=schedule_data["buffer_time"],
|
|
# Convert time strings to time objects only if they exist and handle None gracefully
|
|
break_start_time=time.fromisoformat(break_start) if break_start else None,
|
|
break_end_time=time.fromisoformat(break_end) if break_end else None,
|
|
schedule_interview_type=schedule_data.get("schedule_interview_type")
|
|
)
|
|
except Exception as e:
|
|
# Clear data on failure to prevent stale data causing repeated errors
|
|
messages.error(request, f"Error creating schedule: {e}")
|
|
if SESSION_ID_KEY in request.session: del request.session[SESSION_ID_KEY]
|
|
if SESSION_DATA_KEY in request.session: del request.session[SESSION_DATA_KEY]
|
|
return redirect("schedule_interviews", slug=slug)
|
|
|
|
# 3. Setup candidates and get slots
|
|
candidates = Application.objects.filter(id__in=schedule_data["candidate_ids"])
|
|
schedule.applications.set(candidates)
|
|
available_slots = get_available_time_slots(schedule)
|
|
|
|
# 4. Handle Remote/Onsite logic
|
|
if schedule_data.get("schedule_interview_type") == 'Remote':
|
|
# ... (Remote logic remains unchanged)
|
|
queued_count = 0
|
|
for i, candidate in enumerate(candidates):
|
|
if i < len(available_slots):
|
|
slot = available_slots[i]
|
|
|
|
async_task(
|
|
"recruitment.tasks.create_interview_and_meeting",
|
|
candidate.pk, job.pk, schedule.pk, slot["date"], slot["time"], schedule.interview_duration,
|
|
)
|
|
queued_count += 1
|
|
|
|
messages.success(
|
|
request,
|
|
f"Schedule successfully created. Queued {queued_count} interviews to be booked asynchronously. Check back in a moment!",
|
|
)
|
|
|
|
if SESSION_DATA_KEY in request.session: del request.session[SESSION_DATA_KEY]
|
|
if SESSION_ID_KEY in request.session: del request.session[SESSION_ID_KEY]
|
|
|
|
return redirect("job_detail", slug=slug)
|
|
|
|
elif schedule_data.get("schedule_interview_type") == 'Onsite':
|
|
print("inside...")
|
|
|
|
if request.method == 'POST':
|
|
form = OnsiteLocationForm(request.POST)
|
|
|
|
if form.is_valid():
|
|
|
|
if not available_slots:
|
|
messages.error(request, "No available slots found for the selected schedule range.")
|
|
return render(request, 'interviews/onsite_location_form.html', {'form': form, 'schedule': schedule, 'job': job})
|
|
|
|
# Extract common location data from the form
|
|
physical_address = form.cleaned_data['physical_address']
|
|
room_number = form.cleaned_data['room_number']
|
|
topic=form.cleaned_data['topic']
|
|
|
|
|
|
try:
|
|
# 1. Iterate over candidates and create a NEW Location object for EACH
|
|
for i, candidate in enumerate(candidates):
|
|
if i < len(available_slots):
|
|
slot = available_slots[i]
|
|
|
|
|
|
location_start_dt = datetime.combine(slot['date'], schedule.start_time)
|
|
|
|
# --- CORE FIX: Create a NEW Location object inside the loop ---
|
|
onsite_location = OnsiteLocationDetails.objects.create(
|
|
start_time=location_start_dt,
|
|
duration=schedule.interview_duration,
|
|
physical_address=physical_address,
|
|
room_number=room_number,
|
|
location_type="Onsite",
|
|
topic=topic
|
|
|
|
)
|
|
|
|
# 2. Create the ScheduledInterview, linking the unique location
|
|
ScheduledInterview.objects.create(
|
|
application=candidate,
|
|
job=job,
|
|
schedule=schedule,
|
|
interview_date=slot['date'],
|
|
interview_time=slot['time'],
|
|
interview_location=onsite_location,
|
|
)
|
|
|
|
messages.success(
|
|
request,
|
|
f"Onsite schedule interviews created successfully for {len(candidates)} candidates."
|
|
)
|
|
|
|
# Clear session data keys upon successful completion
|
|
if SESSION_DATA_KEY in request.session: del request.session[SESSION_DATA_KEY]
|
|
if SESSION_ID_KEY in request.session: del request.session[SESSION_ID_KEY]
|
|
|
|
return redirect('job_detail', slug=job.slug)
|
|
|
|
except Exception as e:
|
|
messages.error(request, f"Error creating onsite location/interviews: {e}")
|
|
# On failure, re-render the form with the error and ensure 'job' is present
|
|
return render(request, 'interviews/onsite_location_form.html', {'form': form, 'schedule': schedule, 'job': job})
|
|
|
|
else:
|
|
# Form is invalid, re-render with errors
|
|
# Ensure 'job' is passed to prevent NoReverseMatch
|
|
return render(request, 'interviews/onsite_location_form.html', {'form': form, 'schedule': schedule, 'job': job})
|
|
|
|
else:
|
|
# For a GET request
|
|
form = OnsiteLocationForm()
|
|
|
|
return render(request, 'interviews/onsite_location_form.html', {'form': form, 'schedule': schedule, 'job': job})
|
|
|
|
|
|
|
|
def schedule_interviews_view(request, slug):
|
|
job = get_object_or_404(JobPosting, slug=slug)
|
|
if request.method == "POST":
|
|
# return _handle_confirm_schedule(request, slug, job)
|
|
return _handle_preview_submission(request, slug, job)
|
|
else:
|
|
return _handle_get_request(request, slug, job)
|
|
|
|
|
|
def confirm_schedule_interviews_view(request, slug):
|
|
job = get_object_or_404(JobPosting, slug=slug)
|
|
if request.method == "POST":
|
|
return _handle_confirm_schedule(request, slug, job)
|
|
|
|
|
|
@staff_user_required
|
|
def candidate_screening_view(request, slug):
|
|
"""
|
|
Manage candidate tiers and stage transitions
|
|
"""
|
|
job = get_object_or_404(JobPosting, slug=slug)
|
|
candidates = job.screening_candidates
|
|
|
|
# Get filter parameters
|
|
min_ai_score_str = request.GET.get("min_ai_score")
|
|
min_experience_str = request.GET.get("min_experience")
|
|
screening_rating = request.GET.get("screening_rating")
|
|
tier1_count_str = request.GET.get("tier1_count")
|
|
gpa = request.GET.get("GPA")
|
|
|
|
try:
|
|
# Check if the string value exists and is not an empty string before conversion
|
|
if min_ai_score_str:
|
|
min_ai_score = int(min_ai_score_str)
|
|
else:
|
|
min_ai_score = 0
|
|
|
|
if min_experience_str:
|
|
min_experience = float(min_experience_str)
|
|
else:
|
|
min_experience = 0
|
|
|
|
if tier1_count_str:
|
|
tier1_count = int(tier1_count_str)
|
|
else:
|
|
tier1_count = 0
|
|
|
|
if gpa:
|
|
gpa = float(gpa)
|
|
else:
|
|
gpa = 0
|
|
|
|
except ValueError:
|
|
# This catches if the user enters non-numeric text (e.g., "abc")
|
|
min_ai_score = 0
|
|
min_experience = 0
|
|
tier1_count = 0
|
|
gpa = 0
|
|
|
|
# Apply filters
|
|
if min_ai_score > 0:
|
|
candidates = candidates.filter(
|
|
ai_analysis_data__analysis_data__match_score__gte=min_ai_score
|
|
)
|
|
|
|
if min_experience > 0:
|
|
candidates = candidates.filter(
|
|
ai_analysis_data__analysis_data__years_of_experience__gte=min_experience
|
|
)
|
|
|
|
if screening_rating:
|
|
candidates = candidates.filter(
|
|
ai_analysis_data__analysis_data__screening_stage_rating=screening_rating
|
|
)
|
|
if gpa:
|
|
candidates = candidates.filter(
|
|
person__gpa__gt= gpa
|
|
)
|
|
print(candidates)
|
|
|
|
if tier1_count > 0:
|
|
candidates = candidates[:tier1_count]
|
|
|
|
context = {
|
|
"job": job,
|
|
"candidates": candidates,
|
|
"min_ai_score": min_ai_score,
|
|
"min_experience": min_experience,
|
|
"screening_rating": screening_rating,
|
|
"tier1_count": tier1_count,
|
|
"gpa": gpa,
|
|
"current_stage": "Applied",
|
|
}
|
|
|
|
return render(request, "recruitment/candidate_screening_view.html", context)
|
|
|
|
|
|
@staff_user_required
|
|
def candidate_exam_view(request, slug):
|
|
"""
|
|
Manage candidate tiers and stage transitions
|
|
"""
|
|
job = get_object_or_404(JobPosting, slug=slug)
|
|
context = {"job": job, "candidates": job.exam_candidates, "current_stage": "Exam"}
|
|
return render(request, "recruitment/candidate_exam_view.html", context)
|
|
|
|
|
|
@staff_user_required
|
|
def update_candidate_exam_status(request, slug):
|
|
candidate = get_object_or_404(Application, slug=slug)
|
|
if request.method == "POST":
|
|
form = CandidateExamDateForm(request.POST, instance=candidate)
|
|
if form.is_valid():
|
|
form.save()
|
|
return redirect("candidate_exam_view", slug=candidate.job.slug)
|
|
else:
|
|
form = CandidateExamDateForm(request.POST, instance=candidate)
|
|
return render(
|
|
request,
|
|
"includes/candidate_exam_status_form.html",
|
|
{"candidate": candidate, "form": form},
|
|
)
|
|
|
|
|
|
@staff_user_required
|
|
def bulk_update_candidate_exam_status(request, slug):
|
|
job = get_object_or_404(JobPosting, slug=slug)
|
|
status = request.headers.get("status")
|
|
if status:
|
|
for candidate in get_candidates_from_request(request):
|
|
try:
|
|
if status == "pass":
|
|
candidate.exam_status = "Passed"
|
|
candidate.stage = "Interview"
|
|
else:
|
|
candidate.exam_status = "Failed"
|
|
candidate.save()
|
|
except Exception as e:
|
|
print(e)
|
|
messages.success(request, f"Updated exam status selected candidates")
|
|
return redirect("candidate_exam_view", slug=job.slug)
|
|
|
|
|
|
def candidate_criteria_view_htmx(request, pk):
|
|
candidate = get_object_or_404(Application, pk=pk)
|
|
return render(
|
|
request, "includes/candidate_modal_body.html", {"candidate": candidate}
|
|
)
|
|
|
|
|
|
@staff_user_required
|
|
def candidate_set_exam_date(request, slug):
|
|
candidate = get_object_or_404(Application, slug=slug)
|
|
candidate.exam_date = timezone.now()
|
|
candidate.save()
|
|
messages.success(
|
|
request, f"Set exam date for {candidate.name} to {candidate.exam_date}"
|
|
)
|
|
return redirect("candidate_screening_view", slug=candidate.job.slug)
|
|
|
|
|
|
@staff_user_required
|
|
def candidate_update_status(request, slug):
|
|
job = get_object_or_404(JobPosting, slug=slug)
|
|
mark_as = request.POST.get("mark_as")
|
|
if mark_as != "----------":
|
|
candidate_ids = request.POST.getlist("candidate_ids")
|
|
print(candidate_ids)
|
|
if c := Application.objects.filter(pk__in=candidate_ids):
|
|
if mark_as == "Exam":
|
|
print("exam")
|
|
c.update(
|
|
exam_date=timezone.now(),
|
|
interview_date=None,
|
|
offer_date=None,
|
|
hired_date=None,
|
|
stage=mark_as,
|
|
applicant_status="Candidate"
|
|
if mark_as in ["Exam", "Interview","Document Review", "Offer"]
|
|
else "Applicant",
|
|
)
|
|
elif mark_as == "Interview":
|
|
# interview_date update when scheduling the interview
|
|
print("interview")
|
|
c.update(
|
|
stage=mark_as,
|
|
offer_date=None,
|
|
hired_date=None,
|
|
applicant_status="Candidate"
|
|
if mark_as in ["Exam", "Interview", "Document Review","Offer"]
|
|
else "Applicant",
|
|
)
|
|
elif mark_as == "Document Review":
|
|
print("document review")
|
|
c.update(
|
|
stage=mark_as,
|
|
offer_date=None,
|
|
hired_date=None,
|
|
applicant_status="Candidate"
|
|
if mark_as in ["Exam", "Interview", "Document Review","Offer"]
|
|
else "Applicant",
|
|
)
|
|
elif mark_as == "Offer":
|
|
print("offer")
|
|
c.update(
|
|
stage=mark_as,
|
|
offer_date=timezone.now(),
|
|
hired_date=None,
|
|
applicant_status="Candidate"
|
|
if mark_as in ["Exam", "Interview", "Document Review","Offer"]
|
|
else "Applicant",
|
|
)
|
|
elif mark_as == "Hired":
|
|
print("hired")
|
|
c.update(
|
|
stage=mark_as,
|
|
hired_date=timezone.now(),
|
|
applicant_status="Candidate"
|
|
if mark_as in ["Exam", "Interview", "Offer"]
|
|
else "Applicant",
|
|
)
|
|
else:
|
|
print("rejected")
|
|
c.update(
|
|
stage=mark_as,
|
|
exam_date=None,
|
|
interview_date=None,
|
|
offer_date=None,
|
|
hired_date=None,
|
|
applicant_status="Candidate"
|
|
if mark_as in ["Exam", "Interview", "Offer"]
|
|
else "Applicant",
|
|
)
|
|
|
|
messages.success(request, f"Candidates Updated")
|
|
response = HttpResponse(redirect("candidate_screening_view", slug=job.slug))
|
|
response.headers["HX-Refresh"] = "true"
|
|
return response
|
|
|
|
|
|
@staff_user_required
|
|
def candidate_interview_view(request, slug):
|
|
job = get_object_or_404(JobPosting, slug=slug)
|
|
context = {
|
|
"job": job,
|
|
"candidates": job.interview_candidates,
|
|
"current_stage": "Interview",
|
|
|
|
}
|
|
return render(request, "recruitment/candidate_interview_view.html", context)
|
|
|
|
|
|
@staff_user_required
|
|
def candidate_document_review_view(request, slug):
|
|
"""
|
|
Document review view for candidates after interview stage and before offer stage
|
|
"""
|
|
job = get_object_or_404(JobPosting, slug=slug)
|
|
|
|
# Get candidates from Interview stage who need document review
|
|
candidates = job.document_review_candidates.select_related('person')
|
|
print(candidates)
|
|
# Get search query for filtering
|
|
search_query = request.GET.get('q', '')
|
|
if search_query:
|
|
candidates = candidates.filter(
|
|
Q(person__first_name__icontains=search_query) |
|
|
Q(person__last_name__icontains=search_query) |
|
|
Q(person__email__icontains=search_query)
|
|
)
|
|
|
|
context = {
|
|
"job": job,
|
|
"candidates": candidates,
|
|
"current_stage": "Document Review",
|
|
"search_query": search_query,
|
|
}
|
|
return render(request, "recruitment/candidate_document_review_view.html", context)
|
|
|
|
|
|
@staff_user_required
|
|
def reschedule_meeting_for_candidate(request, slug, candidate_id, meeting_id):
|
|
job = get_object_or_404(JobPosting, slug=slug)
|
|
candidate = get_object_or_404(Application, pk=candidate_id)
|
|
meeting = get_object_or_404(ZoomMeetingDetails, pk=meeting_id)
|
|
form = ZoomMeetingForm(instance=meeting)
|
|
|
|
if request.method == "POST":
|
|
form = ZoomMeetingForm(request.POST, instance=meeting)
|
|
if form.is_valid():
|
|
instance = form.save(commit=False)
|
|
updated_data = {
|
|
"topic": instance.topic,
|
|
"start_time": instance.start_time.isoformat() + "Z",
|
|
"duration": instance.duration,
|
|
}
|
|
if instance.start_time < timezone.now():
|
|
messages.error(request, "Start time must be in the future.")
|
|
return redirect(
|
|
"reschedule_meeting_for_candidate",
|
|
slug=job.slug,
|
|
candidate_id=candidate_id,
|
|
meeting_id=meeting_id,
|
|
)
|
|
|
|
result = update_meeting(instance, updated_data)
|
|
|
|
if result["status"] == "success":
|
|
messages.success(request, result["message"])
|
|
else:
|
|
messages.error(request, result["message"])
|
|
return redirect(
|
|
reverse("candidate_interview_view", kwargs={"slug": job.slug})
|
|
)
|
|
|
|
context = {"job": job, "candidate": candidate, "meeting": meeting, "form": form}
|
|
return render(request, "meetings/reschedule_meeting.html", context)
|
|
|
|
|
|
@staff_user_required
|
|
def delete_meeting_for_candidate(request, slug, candidate_pk, meeting_id):
|
|
job = get_object_or_404(JobPosting, slug=slug)
|
|
candidate = get_object_or_404(Application, pk=candidate_pk)
|
|
meeting = get_object_or_404(ZoomMeetingDetails, pk=meeting_id)
|
|
if request.method == "POST":
|
|
result = delete_zoom_meeting(meeting.meeting_id)
|
|
if (
|
|
result["status"] == "success"
|
|
or "Meeting does not exist" in result["details"]["message"]
|
|
):
|
|
meeting.delete()
|
|
messages.success(request, "Meeting deleted successfully")
|
|
else:
|
|
messages.error(request, result["message"])
|
|
return redirect(reverse("candidate_interview_view", kwargs={"slug": job.slug}))
|
|
|
|
context = {
|
|
"job": job,
|
|
"candidate": candidate,
|
|
"meeting": meeting,
|
|
"delete_url": reverse(
|
|
"delete_meeting_for_candidate",
|
|
kwargs={
|
|
"slug": job.slug,
|
|
"candidate_pk": candidate_pk,
|
|
"meeting_id": meeting_id,
|
|
},
|
|
),
|
|
}
|
|
return render(request, "meetings/delete_meeting_form.html", context)
|
|
|
|
@staff_user_required
|
|
def delete_zoom_meeting_for_candidate(request, slug, candidate_pk, meeting_id):
|
|
"""
|
|
Deletes a specific Zoom (Remote) meeting instance.
|
|
The ZoomMeetingDetails object inherits from InterviewLocation,
|
|
which is linked to ScheduledInterview. Deleting the subclass
|
|
should trigger CASCADE/SET_NULL correctly on the FK chain.
|
|
"""
|
|
job = get_object_or_404(JobPosting, slug=slug)
|
|
candidate = get_object_or_404(Application, pk=candidate_pk)
|
|
|
|
# Target the specific Zoom meeting details instance
|
|
meeting = get_object_or_404(ZoomMeetingDetails, pk=meeting_id)
|
|
|
|
if request.method == "POST":
|
|
# 1. Attempt to delete the meeting from the external Zoom API
|
|
result = delete_zoom_meeting(meeting.meeting_id)
|
|
|
|
# 2. Check for success OR if the meeting was already deleted externally
|
|
if (
|
|
result["status"] == "success"
|
|
or "Meeting does not exist" in result["details"]["message"]
|
|
):
|
|
# 3. Delete the local Django object. This will delete the base
|
|
# InterviewLocation object and update the ScheduledInterview FK.
|
|
meeting.delete()
|
|
messages.success(request, f"Remote meeting for {candidate.name} deleted successfully.")
|
|
else:
|
|
messages.error(request, result["message"])
|
|
|
|
return redirect(reverse("candidate_interview_view", kwargs={"slug": job.slug}))
|
|
|
|
context = {
|
|
"job": job,
|
|
"candidate": candidate,
|
|
"meeting": meeting,
|
|
"location_type": "Remote",
|
|
"delete_url": reverse(
|
|
"delete_remote_meeting_for_candidate", # Use the specific new URL name
|
|
kwargs={
|
|
"slug": job.slug,
|
|
"candidate_pk": candidate_pk,
|
|
"meeting_id": meeting_id,
|
|
},
|
|
),
|
|
}
|
|
return render(request, "meetings/delete_meeting_form.html", context)
|
|
|
|
@staff_user_required
|
|
def interview_calendar_view(request, slug):
|
|
job = get_object_or_404(JobPosting, slug=slug)
|
|
|
|
# Get all scheduled interviews for this job
|
|
scheduled_interviews = ScheduledInterview.objects.filter(job=job).select_related(
|
|
"applicaton", "zoom_meeting"
|
|
)
|
|
|
|
# Convert interviews to calendar events
|
|
events = []
|
|
for interview in scheduled_interviews:
|
|
# Create start datetime
|
|
start_datetime = datetime.combine(
|
|
interview.interview_date, interview.interview_time
|
|
)
|
|
|
|
# Calculate end datetime based on interview duration
|
|
duration = interview.zoom_meeting.duration if interview.zoom_meeting else 60
|
|
end_datetime = start_datetime + timedelta(minutes=duration)
|
|
|
|
# Determine event color based on status
|
|
color = "#00636e" # Default color
|
|
if interview.status == "confirmed":
|
|
color = "#00a86b" # Green for confirmed
|
|
elif interview.status == "cancelled":
|
|
color = "#e74c3c" # Red for cancelled
|
|
elif interview.status == "completed":
|
|
color = "#95a5a6" # Gray for completed
|
|
|
|
events.append(
|
|
{
|
|
"title": f"Interview: {interview.candidate.name}",
|
|
"start": start_datetime.isoformat(),
|
|
"end": end_datetime.isoformat(),
|
|
"url": f"{request.path}interview/{interview.id}/",
|
|
"color": color,
|
|
"extendedProps": {
|
|
"candidate": interview.candidate.name,
|
|
"email": interview.candidate.email,
|
|
"status": interview.status,
|
|
"meeting_id": interview.zoom_meeting.meeting_id
|
|
if interview.zoom_meeting
|
|
else None,
|
|
"join_url": interview.zoom_meeting.join_url
|
|
if interview.zoom_meeting
|
|
else None,
|
|
},
|
|
}
|
|
)
|
|
|
|
context = {
|
|
"job": job,
|
|
"events": events,
|
|
"calendar_color": "#00636e",
|
|
}
|
|
|
|
return render(request, "recruitment/interview_calendar.html", context)
|
|
|
|
|
|
@staff_user_required
|
|
def interview_detail_view(request, slug, interview_id):
|
|
job = get_object_or_404(JobPosting, slug=slug)
|
|
interview = get_object_or_404(ScheduledInterview, id=interview_id, job=job)
|
|
|
|
context = {
|
|
"job": job,
|
|
"interview": interview,
|
|
}
|
|
|
|
return render(request, "recruitment/interview_detail.html", context)
|
|
|
|
|
|
# Candidate Meeting Scheduling/Rescheduling Views
|
|
@require_POST
|
|
def api_schedule_candidate_meeting(request, job_slug, candidate_pk):
|
|
"""
|
|
Handle POST request to schedule a Zoom meeting for a candidate via HTMX.
|
|
Returns JSON response for modal update.
|
|
"""
|
|
job = get_object_or_404(JobPosting, slug=job_slug)
|
|
candidate = get_object_or_404(Application, pk=candidate_pk, job=job)
|
|
|
|
topic = f"Interview: {job.title} with {candidate.name}"
|
|
start_time_str = request.POST.get("start_time")
|
|
duration = int(request.POST.get("duration", 60))
|
|
|
|
if not start_time_str:
|
|
return JsonResponse(
|
|
{"success": False, "error": "Start time is required."}, status=400
|
|
)
|
|
|
|
try:
|
|
# Parse datetime from datetime-local input (YYYY-MM-DDTHH:MM)
|
|
# This will be in server's timezone, create_zoom_meeting will handle UTC conversion
|
|
naive_start_time = datetime.fromisoformat(start_time_str)
|
|
# Ensure it's timezone-aware if your system requires it, or let create_zoom_meeting handle it.
|
|
# For simplicity, assuming create_zoom_meeting handles naive datetimes or they are in UTC.
|
|
# If start_time is expected to be in a specific timezone, convert it here.
|
|
# e.g., start_time = timezone.make_aware(naive_start_time, timezone.get_current_timezone())
|
|
start_time = naive_start_time # Or timezone.make_aware(naive_start_time)
|
|
except ValueError:
|
|
return JsonResponse(
|
|
{"success": False, "error": "Invalid date/time format for start time."},
|
|
status=400,
|
|
)
|
|
|
|
if start_time <= timezone.now():
|
|
return JsonResponse(
|
|
{"success": False, "error": "Start time must be in the future."}, status=400
|
|
)
|
|
|
|
result = create_zoom_meeting(topic=topic, start_time=start_time, duration=duration)
|
|
|
|
if result["status"] == "success":
|
|
zoom_meeting_details = result["meeting_details"]
|
|
zoom_meeting = ZoomMeetingDetails.objects.create(
|
|
topic=topic,
|
|
start_time=start_time, # Store in local timezone
|
|
duration=duration,
|
|
meeting_id=zoom_meeting_details["meeting_id"],
|
|
join_url=zoom_meeting_details["join_url"],
|
|
password=zoom_meeting_details["password"],
|
|
# host_email=zoom_meeting_details["host_email"],
|
|
status=result["zoom_gateway_response"].get("status", "waiting"),
|
|
zoom_gateway_response=result["zoom_gateway_response"],
|
|
)
|
|
scheduled_interview = ScheduledInterview.objects.create(
|
|
candidate=candidate,
|
|
job=job,
|
|
zoom_meeting=zoom_meeting,
|
|
interview_date=start_time.date(),
|
|
interview_time=start_time.time(),
|
|
status="scheduled", # Or 'confirmed' depending on your workflow
|
|
)
|
|
messages.success(request, f"Meeting scheduled with {candidate.name}.")
|
|
|
|
# Return updated table row or a success message
|
|
# For HTMX, you might want to return a fragment of the updated table
|
|
# For now, returning JSON to indicate success and close modal
|
|
return JsonResponse(
|
|
{
|
|
"success": True,
|
|
"message": "Meeting scheduled successfully!",
|
|
"join_url": zoom_meeting.join_url,
|
|
"meeting_id": zoom_meeting.meeting_id,
|
|
"candidate_name": candidate.name,
|
|
"interview_datetime": start_time.strftime("%Y-%m-%d %H:%M"),
|
|
}
|
|
)
|
|
else:
|
|
messages.error(request, result["message"])
|
|
return JsonResponse({"success": False, "error": result["message"]}, status=400)
|
|
|
|
|
|
def schedule_candidate_meeting(request, job_slug, candidate_pk):
|
|
"""
|
|
GET: Render modal form to schedule a meeting. (For HTMX)
|
|
POST: Handled by api_schedule_candidate_meeting.
|
|
"""
|
|
job = get_object_or_404(JobPosting, slug=job_slug)
|
|
candidate = get_object_or_404(Application, pk=candidate_pk, job=job)
|
|
|
|
if request.method == "POST":
|
|
return api_schedule_candidate_meeting(request, job_slug, candidate_pk)
|
|
|
|
# GET request - render the form snippet for HTMX
|
|
context = {
|
|
"job": job,
|
|
"candidate": candidate,
|
|
"action_url": reverse(
|
|
"api_schedule_candidate_meeting",
|
|
kwargs={"job_slug": job_slug, "candidate_pk": candidate_pk},
|
|
),
|
|
"scheduled_interview": None, # Explicitly None for schedule
|
|
}
|
|
# Render just the form part, or the whole modal body content
|
|
return render(request, "includes/meeting_form.html", context)
|
|
|
|
|
|
@require_http_methods(["GET", "POST"])
|
|
def api_schedule_candidate_meeting(request, job_slug, candidate_pk):
|
|
"""
|
|
Handles GET to render form and POST to process scheduling.
|
|
"""
|
|
job = get_object_or_404(JobPosting, slug=job_slug)
|
|
candidate = get_object_or_404(Application, pk=candidate_pk, job=job)
|
|
|
|
if request.method == "GET":
|
|
# This GET is for HTMX to fetch the form
|
|
context = {
|
|
"job": job,
|
|
"candidate": candidate,
|
|
"action_url": reverse(
|
|
"api_schedule_candidate_meeting",
|
|
kwargs={"job_slug": job_slug, "candidate_pk": candidate_pk},
|
|
),
|
|
"scheduled_interview": None,
|
|
}
|
|
return render(request, "includes/meeting_form.html", context)
|
|
|
|
# POST logic (remains the same)
|
|
topic = f"Interview: {job.title} with {candidate.name}"
|
|
start_time_str = request.POST.get("start_time")
|
|
duration = int(request.POST.get("duration", 60))
|
|
|
|
if not start_time_str:
|
|
return JsonResponse(
|
|
{"success": False, "error": "Start time is required."}, status=400
|
|
)
|
|
|
|
try:
|
|
naive_start_time = datetime.fromisoformat(start_time_str)
|
|
start_time = naive_start_time
|
|
except ValueError:
|
|
return JsonResponse(
|
|
{"success": False, "error": "Invalid date/time format for start time."},
|
|
status=400,
|
|
)
|
|
|
|
if start_time <= timezone.now():
|
|
return JsonResponse(
|
|
{"success": False, "error": "Start time must be in the future."}, status=400
|
|
)
|
|
|
|
result = create_zoom_meeting(topic=topic, start_time=start_time, duration=duration)
|
|
|
|
if result["status"] == "success":
|
|
zoom_meeting_details = result["meeting_details"]
|
|
zoom_meeting = ZoomMeetingDetails.objects.create(
|
|
topic=topic,
|
|
start_time=start_time,
|
|
duration=duration,
|
|
meeting_id=zoom_meeting_details["meeting_id"],
|
|
join_url=zoom_meeting_details["join_url"],
|
|
password=zoom_meeting_details["password"],
|
|
host_email=zoom_meeting_details["host_email"],
|
|
status=result["zoom_gateway_response"].get("status", "waiting"),
|
|
zoom_gateway_response=result["zoom_gateway_response"],
|
|
)
|
|
scheduled_interview = ScheduledInterview.objects.create(
|
|
candidate=candidate,
|
|
job=job,
|
|
zoom_meeting=zoom_meeting,
|
|
interview_date=start_time.date(),
|
|
interview_time=start_time.time(),
|
|
status="scheduled",
|
|
)
|
|
messages.success(request, f"Meeting scheduled with {candidate.name}.")
|
|
return JsonResponse(
|
|
{
|
|
"success": True,
|
|
"message": "Meeting scheduled successfully!",
|
|
"join_url": zoom_meeting.join_url,
|
|
"meeting_id": zoom_meeting.meeting_id,
|
|
"candidate_name": candidate.name,
|
|
"interview_datetime": start_time.strftime("%Y-%m-%d %H:%M"),
|
|
}
|
|
)
|
|
else:
|
|
messages.error(request, result["message"])
|
|
return JsonResponse({"success": False, "error": result["message"]}, status=400)
|
|
|
|
|
|
@require_http_methods(["GET", "POST"])
|
|
def api_reschedule_candidate_meeting(request, job_slug, candidate_pk, interview_pk):
|
|
"""
|
|
Handles GET to render form and POST to process rescheduling.
|
|
"""
|
|
job = get_object_or_404(JobPosting, slug=job_slug)
|
|
scheduled_interview = get_object_or_404(
|
|
ScheduledInterview.objects.select_related("zoom_meeting"),
|
|
pk=interview_pk,
|
|
application__pk=candidate_pk,
|
|
job=job,
|
|
)
|
|
zoom_meeting = scheduled_interview.zoom_meeting
|
|
|
|
if request.method == "GET":
|
|
# This GET is for HTMX to fetch the form
|
|
initial_data = {
|
|
"topic": zoom_meeting.topic,
|
|
"start_time": zoom_meeting.start_time.strftime("%Y-%m-%dT%H:%M"),
|
|
"duration": zoom_meeting.duration,
|
|
}
|
|
context = {
|
|
"job": job,
|
|
"candidate": scheduled_interview.application,
|
|
"scheduled_interview": scheduled_interview, # Pass for conditional logic in template
|
|
"initial_data": initial_data,
|
|
"action_url": reverse(
|
|
"api_reschedule_candidate_meeting",
|
|
kwargs={
|
|
"job_slug": job_slug,
|
|
"candidate_pk": candidate_pk,
|
|
"interview_pk": interview_pk,
|
|
},
|
|
),
|
|
}
|
|
return render(request, "includes/meeting_form.html", context)
|
|
|
|
# POST logic (remains the same)
|
|
new_start_time_str = request.POST.get("start_time")
|
|
new_duration = int(request.POST.get("duration", zoom_meeting.duration))
|
|
|
|
if not new_start_time_str:
|
|
return JsonResponse(
|
|
{"success": False, "error": "New start time is required."}, status=400
|
|
)
|
|
|
|
try:
|
|
naive_new_start_time = datetime.fromisoformat(new_start_time_str)
|
|
new_start_time = naive_new_start_time
|
|
except ValueError:
|
|
return JsonResponse(
|
|
{"success": False, "error": "Invalid date/time format for new start time."},
|
|
status=400,
|
|
)
|
|
|
|
if new_start_time <= timezone.now():
|
|
return JsonResponse(
|
|
{"success": False, "error": "Start time must be in the future."}, status=400
|
|
)
|
|
|
|
updated_data = {
|
|
"topic": f"Interview: {job.title} with {scheduled_interview.candidate.name}",
|
|
"start_time": new_start_time.isoformat() + "Z",
|
|
"duration": new_duration,
|
|
}
|
|
|
|
result = update_zoom_meeting(zoom_meeting.meeting_id, updated_data)
|
|
|
|
if result["status"] == "success":
|
|
details_result = get_zoom_meeting_details(zoom_meeting.meeting_id)
|
|
if details_result["status"] == "success":
|
|
updated_zoom_details = details_result["meeting_details"]
|
|
zoom_meeting.topic = updated_zoom_details.get("topic", zoom_meeting.topic)
|
|
zoom_meeting.start_time = new_start_time
|
|
zoom_meeting.duration = new_duration
|
|
zoom_meeting.join_url = updated_zoom_details.get(
|
|
"join_url", zoom_meeting.join_url
|
|
)
|
|
zoom_meeting.password = updated_zoom_details.get(
|
|
"password", zoom_meeting.password
|
|
)
|
|
zoom_meeting.status = updated_zoom_details.get(
|
|
"status", zoom_meeting.status
|
|
)
|
|
zoom_meeting.zoom_gateway_response = updated_zoom_details
|
|
zoom_meeting.save()
|
|
|
|
scheduled_interview.interview_date = new_start_time.date()
|
|
scheduled_interview.interview_time = new_start_time.time()
|
|
scheduled_interview.status = "rescheduled"
|
|
scheduled_interview.save()
|
|
messages.success(
|
|
request,
|
|
f"Meeting for {scheduled_interview.candidate.name} rescheduled.",
|
|
)
|
|
else:
|
|
logger.warning(
|
|
f"Zoom meeting {zoom_meeting.meeting_id} updated, but failed to fetch latest details."
|
|
)
|
|
zoom_meeting.start_time = new_start_time
|
|
zoom_meeting.duration = new_duration
|
|
zoom_meeting.save()
|
|
scheduled_interview.interview_date = new_start_time.date()
|
|
scheduled_interview.interview_time = new_start_time.time()
|
|
scheduled_interview.save()
|
|
messages.success(
|
|
request,
|
|
f"Meeting for {scheduled_interview.candidate.name} rescheduled. (Note: Could not refresh all details from Zoom.)",
|
|
)
|
|
|
|
return JsonResponse(
|
|
{
|
|
"success": True,
|
|
"message": "Meeting rescheduled successfully!",
|
|
"join_url": zoom_meeting.join_url,
|
|
"new_interview_datetime": new_start_time.strftime("%Y-%m-%d %H:%M"),
|
|
}
|
|
)
|
|
else:
|
|
messages.error(request, result["message"])
|
|
return JsonResponse({"success": False, "error": result["message"]}, status=400)
|
|
|
|
|
|
# The original schedule_candidate_meeting and reschedule_candidate_meeting (without api_ prefix)
|
|
# can be removed if their only purpose was to be called by the JS onclicks.
|
|
# If they were intended for other direct URL access, they can be kept as simple redirects
|
|
# or wrappers to the api_ versions.
|
|
# For now, let's assume the api_ versions are the primary ones for HTMX.
|
|
|
|
|
|
def reschedule_candidate_meeting(request, job_slug, candidate_pk, interview_pk):
|
|
"""
|
|
Handles GET to display a form for rescheduling a meeting.
|
|
Handles POST to process the rescheduling of a meeting.
|
|
"""
|
|
job = get_object_or_404(JobPosting, slug=job_slug)
|
|
application = get_object_or_404(Application, pk=candidate_pk, job=job)
|
|
scheduled_interview = get_object_or_404(
|
|
ScheduledInterview.objects.select_related("zoom_meeting"),
|
|
pk=interview_pk,
|
|
application=application,
|
|
job=job,
|
|
)
|
|
zoom_meeting = scheduled_interview.zoom_meeting
|
|
|
|
# Determine if the candidate has other future meetings
|
|
# This helps in providing context in the template
|
|
# Note: This checks for *any* future meetings for the candidate, not just the one being rescheduled.
|
|
# If candidate.has_future_meeting is True, it implies they have at least one other upcoming meeting,
|
|
# or the specific meeting being rescheduled is itself in the future.
|
|
# We can refine this logic if needed, e.g., check for meetings *other than* the current `interview_pk`.
|
|
has_other_future_meetings = application.has_future_meeting
|
|
# More precise check: if the current meeting being rescheduled is in the future, then by definition
|
|
# the candidate will have a future meeting (this one). The UI might want to know if there are *others*.
|
|
# For now, `candidate.has_future_meeting` is a good general indicator.
|
|
|
|
if request.method == "POST":
|
|
form = ZoomMeetingForm(request.POST)
|
|
if form.is_valid():
|
|
new_topic = form.cleaned_data.get("topic")
|
|
new_start_time = form.cleaned_data.get("start_time")
|
|
new_duration = form.cleaned_data.get("duration")
|
|
|
|
# Use a default topic if not provided, keeping with the original structure
|
|
if not new_topic:
|
|
new_topic = f"Interview: {job.title} with {application.name}"
|
|
|
|
# Ensure new_start_time is in the future
|
|
if new_start_time <= timezone.now():
|
|
messages.error(request, "Start time must be in the future.")
|
|
# Re-render form with error and initial data
|
|
return render(
|
|
request,
|
|
"recruitment/schedule_meeting_form.html",
|
|
{ # Reusing the same form template
|
|
"form": form,
|
|
"job": job,
|
|
"application": application,
|
|
"scheduled_interview": scheduled_interview,
|
|
"initial_topic": new_topic,
|
|
"initial_start_time": new_start_time.strftime("%Y-%m-%dT%H:%M")
|
|
if new_start_time
|
|
else "",
|
|
"initial_duration": new_duration,
|
|
"action_url": reverse(
|
|
"reschedule_candidate_meeting",
|
|
kwargs={
|
|
"job_slug": job_slug,
|
|
"candidate_pk": candidate_pk,
|
|
"interview_pk": interview_pk,
|
|
},
|
|
),
|
|
"has_future_meeting": has_other_future_meetings, # Pass status for template
|
|
},
|
|
)
|
|
|
|
# Prepare data for Zoom API update
|
|
# The update_zoom_meeting expects start_time as ISO string with 'Z'
|
|
zoom_update_data = {
|
|
"topic": new_topic,
|
|
"start_time": new_start_time.isoformat() + "Z",
|
|
"duration": new_duration,
|
|
}
|
|
|
|
# Update Zoom meeting using utility function
|
|
zoom_update_result = update_zoom_meeting(
|
|
zoom_meeting.meeting_id, zoom_update_data
|
|
)
|
|
|
|
if zoom_update_result["status"] == "success":
|
|
# Fetch the latest details from Zoom after successful update
|
|
details_result = get_zoom_meeting_details(zoom_meeting.meeting_id)
|
|
|
|
if details_result["status"] == "success":
|
|
updated_zoom_details = details_result["meeting_details"]
|
|
# Update local ZoomMeeting record
|
|
zoom_meeting.topic = updated_zoom_details.get("topic", new_topic)
|
|
zoom_meeting.start_time = (
|
|
new_start_time # Store the original datetime
|
|
)
|
|
zoom_meeting.duration = new_duration
|
|
zoom_meeting.join_url = updated_zoom_details.get(
|
|
"join_url", zoom_meeting.join_url
|
|
)
|
|
zoom_meeting.password = updated_zoom_details.get(
|
|
"password", zoom_meeting.password
|
|
)
|
|
zoom_meeting.status = updated_zoom_details.get(
|
|
"status", zoom_meeting.status
|
|
)
|
|
zoom_meeting.zoom_gateway_response = details_result.get(
|
|
"meeting_details"
|
|
)
|
|
zoom_meeting.save()
|
|
|
|
# Update ScheduledInterview record
|
|
scheduled_interview.interview_date = new_start_time.date()
|
|
scheduled_interview.interview_time = new_start_time.time()
|
|
scheduled_interview.status = (
|
|
"rescheduled" # Or 'scheduled' if you prefer
|
|
)
|
|
scheduled_interview.save()
|
|
messages.success(
|
|
request,
|
|
f"Meeting for {application.name} rescheduled successfully.",
|
|
)
|
|
else:
|
|
# If fetching details fails, update with form data and log a warning
|
|
logger.warning(
|
|
f"Successfully updated Zoom meeting {zoom_meeting.meeting_id}, but failed to fetch updated details. "
|
|
f"Error: {details_result.get('message', 'Unknown error')}"
|
|
)
|
|
# Update with form data as a fallback
|
|
zoom_meeting.topic = new_topic
|
|
zoom_meeting.start_time = new_start_time
|
|
zoom_meeting.duration = new_duration
|
|
zoom_meeting.save()
|
|
scheduled_interview.interview_date = new_start_time.date()
|
|
scheduled_interview.interview_time = new_start_time.time()
|
|
scheduled_interview.save()
|
|
messages.success(
|
|
request,
|
|
f"Meeting for {application.name} rescheduled. (Note: Could not refresh all details from Zoom.)",
|
|
)
|
|
|
|
return redirect("candidate_interview_view", slug=job.slug)
|
|
else:
|
|
messages.error(
|
|
request,
|
|
f"Failed to update Zoom meeting: {zoom_update_result['message']}",
|
|
)
|
|
# Re-render form with error
|
|
return render(
|
|
request,
|
|
"recruitment/schedule_meeting_form.html",
|
|
{
|
|
"form": form,
|
|
"job": job,
|
|
"application": application,
|
|
"scheduled_interview": scheduled_interview,
|
|
"initial_topic": new_topic,
|
|
"initial_start_time": new_start_time.strftime("%Y-%m-%dT%H:%M")
|
|
if new_start_time
|
|
else "",
|
|
"initial_duration": new_duration,
|
|
"action_url": reverse(
|
|
"reschedule_candidate_meeting",
|
|
kwargs={
|
|
"job_slug": job_slug,
|
|
"candidate_pk": candidate_pk,
|
|
"interview_pk": interview_pk,
|
|
},
|
|
),
|
|
"has_future_meeting": has_other_future_meetings,
|
|
},
|
|
)
|
|
else:
|
|
# Form validation errors
|
|
return render(
|
|
request,
|
|
"recruitment/schedule_meeting_form.html",
|
|
{
|
|
"form": form,
|
|
"job": job,
|
|
"application": application,
|
|
"scheduled_interview": scheduled_interview,
|
|
"initial_topic": request.POST.get("topic", new_topic),
|
|
"initial_start_time": request.POST.get(
|
|
"start_time",
|
|
new_start_time.strftime("%Y-%m-%dT%H:%M")
|
|
if new_start_time
|
|
else "",
|
|
),
|
|
"initial_duration": request.POST.get("duration", new_duration),
|
|
"action_url": reverse(
|
|
"reschedule_candidate_meeting",
|
|
kwargs={
|
|
"job_slug": job_slug,
|
|
"candidate_pk": candidate_pk,
|
|
"interview_pk": interview_pk,
|
|
},
|
|
),
|
|
"has_future_meeting": has_other_future_meetings,
|
|
},
|
|
)
|
|
else: # GET request
|
|
# Pre-populate form with existing meeting details
|
|
initial_data = {
|
|
"topic": zoom_meeting.topic,
|
|
"start_time": zoom_meeting.start_time.strftime("%Y-%m-%dT%H:%M"),
|
|
"duration": zoom_meeting.duration,
|
|
}
|
|
form = ZoomMeetingForm(initial=initial_data)
|
|
return render(
|
|
request,
|
|
"recruitment/schedule_meeting_form.html",
|
|
{
|
|
"form": form,
|
|
"job": job,
|
|
"application": application,
|
|
"scheduled_interview": scheduled_interview, # Pass to template for title/differentiation
|
|
"action_url": reverse(
|
|
"reschedule_candidate_meeting",
|
|
kwargs={
|
|
"job_slug": job_slug,
|
|
"candidate_pk": candidate_pk,
|
|
"interview_pk": interview_pk,
|
|
},
|
|
),
|
|
"has_future_meeting": has_other_future_meetings, # Pass status for template
|
|
},
|
|
)
|
|
|
|
|
|
def schedule_meeting_for_candidate(request, slug, candidate_pk):
|
|
"""
|
|
Handles GET to display a simple form for scheduling a meeting for a candidate.
|
|
Handles POST to process the form, create a meeting, and redirect back.
|
|
"""
|
|
job = get_object_or_404(JobPosting, slug=slug)
|
|
candidate = get_object_or_404(Application, pk=candidate_pk, job=job)
|
|
|
|
if request.method == "POST":
|
|
form = ZoomMeetingForm(request.POST)
|
|
if form.is_valid():
|
|
topic_val = form.cleaned_data.get("topic")
|
|
start_time_val = form.cleaned_data.get("start_time")
|
|
duration_val = form.cleaned_data.get("duration")
|
|
|
|
# Use a default topic if not provided
|
|
if not topic_val:
|
|
topic_val = f"Interview: {job.title} with {candidate.name}"
|
|
|
|
# Ensure start_time is in the future
|
|
if start_time_val <= timezone.now():
|
|
messages.error(request, "Start time must be in the future.")
|
|
# Re-render form with error and initial data
|
|
return redirect("candidate_interview_view", slug=job.slug)
|
|
# return render(request, "recruitment/schedule_meeting_form.html", {
|
|
# 'form': form,
|
|
# 'job': job,
|
|
# 'candidate': candidate,
|
|
# 'initial_topic': topic_val,
|
|
# 'initial_start_time': start_time_val.strftime('%Y-%m-%dT%H:%M') if start_time_val else '',
|
|
# 'initial_duration': duration_val
|
|
# })
|
|
|
|
# Create Zoom meeting using utility function
|
|
# The create_zoom_meeting expects start_time as a datetime object
|
|
# and handles its own conversion to UTC for the API call.
|
|
zoom_creation_result = create_zoom_meeting(
|
|
topic=topic_val,
|
|
start_time=start_time_val, # Pass the datetime object
|
|
duration=duration_val,
|
|
)
|
|
|
|
if zoom_creation_result["status"] == "success":
|
|
zoom_details = zoom_creation_result["meeting_details"]
|
|
zoom_meeting_instance = ZoomMeetingDetails.objects.create(
|
|
topic=topic_val,
|
|
start_time=start_time_val, # Store the original datetime
|
|
duration=duration_val,
|
|
meeting_id=zoom_details["meeting_id"],
|
|
details_url=zoom_details["join_url"],
|
|
password=zoom_details.get("password"), # password might be None
|
|
status=zoom_creation_result["zoom_gateway_response"].get(
|
|
"status", "waiting"
|
|
),
|
|
zoom_gateway_response=zoom_creation_result["zoom_gateway_response"],
|
|
location_type='Remote',
|
|
|
|
)
|
|
# Create a ScheduledInterview record
|
|
ScheduledInterview.objects.create(
|
|
application=candidate,
|
|
job=job,
|
|
interview_location=zoom_meeting_instance,
|
|
interview_date=start_time_val.date(),
|
|
interview_time=start_time_val.time(),
|
|
status="scheduled",
|
|
)
|
|
messages.success(request, f"Meeting scheduled with {candidate.name}.")
|
|
return redirect("candidate_interview_view", slug=job.slug)
|
|
else:
|
|
messages.error(
|
|
request,
|
|
f"Failed to create Zoom meeting: {zoom_creation_result['message']}",
|
|
)
|
|
# Re-render form with error
|
|
return render(
|
|
request,
|
|
"recruitment/schedule_meeting_form.html",
|
|
{
|
|
"form": form,
|
|
"job": job,
|
|
"candidate": candidate,
|
|
"initial_topic": topic_val,
|
|
"initial_start_time": start_time_val.strftime("%Y-%m-%dT%H:%M")
|
|
if start_time_val
|
|
else "",
|
|
"initial_duration": duration_val,
|
|
},
|
|
)
|
|
else:
|
|
# Form validation errors
|
|
return render(
|
|
request,
|
|
"meetings/schedule_meeting_form.html",
|
|
{
|
|
"form": form,
|
|
"job": job,
|
|
"candidate": candidate,
|
|
"initial_topic": request.POST.get(
|
|
"topic", f"Interview: {job.title} with {candidate.name}"
|
|
),
|
|
"initial_start_time": request.POST.get("start_time", ""),
|
|
"initial_duration": request.POST.get("duration", 60),
|
|
},
|
|
)
|
|
else: # GET request
|
|
initial_data = {
|
|
"topic": f"Interview: {job.title} with {candidate.name}",
|
|
"start_time": (timezone.now() + timedelta(hours=1)).strftime(
|
|
"%Y-%m-%dT%H:%M"
|
|
), # Default to 1 hour from now
|
|
"duration": 60, # Default duration
|
|
}
|
|
form = ZoomMeetingForm(initial=initial_data)
|
|
return render(
|
|
request,
|
|
"meetings/schedule_meeting_form.html",
|
|
{"form": form, "job": job, "candidate": candidate},
|
|
)
|
|
|
|
|
|
from django.core.exceptions import ObjectDoesNotExist
|
|
|
|
|
|
def user_profile_image_update(request, pk):
|
|
user = get_object_or_404(User, pk=pk)
|
|
|
|
if request.method == "POST":
|
|
profile_form = ProfileImageUploadForm(
|
|
request.POST, request.FILES, instance=user
|
|
)
|
|
if profile_form.is_valid():
|
|
profile_form.save()
|
|
messages.success(request, "Image uploaded successfully")
|
|
return redirect("user_detail", pk=user.pk)
|
|
else:
|
|
messages.error(
|
|
request,
|
|
"An error occurred while uploading image. Please check errors below.",
|
|
)
|
|
else:
|
|
profile_form = ProfileImageUploadForm(instance=user)
|
|
|
|
context = {
|
|
"profile_form": profile_form,
|
|
"user": user,
|
|
}
|
|
return render(request, "user/profile.html", context)
|
|
|
|
|
|
def user_detail(request, pk):
|
|
user = get_object_or_404(User, pk=pk)
|
|
|
|
profile_form = ProfileImageUploadForm(instance=user)
|
|
|
|
if request.method == "POST":
|
|
first_name = request.POST.get("first_name")
|
|
last_name = request.POST.get("last_name")
|
|
if first_name:
|
|
user.first_name = first_name
|
|
if last_name:
|
|
user.last_name = last_name
|
|
user.save()
|
|
context = {"user": user, "profile_form": profile_form,"password_reset_form":PasswordResetForm()}
|
|
if request.user.user_type != "staff":
|
|
return render(request, "user/portal_profile.html", context)
|
|
return render(request, "user/profile.html", context)
|
|
|
|
|
|
def easy_logs(request):
|
|
"""
|
|
Function-based view to display Django Easy Audit logs with tab switching and pagination.
|
|
"""
|
|
logs_per_page = 20
|
|
|
|
active_tab = request.GET.get("tab", "crud")
|
|
|
|
if active_tab == "login":
|
|
queryset = LoginEvent.objects.order_by("-datetime")
|
|
tab_title = _("User Authentication")
|
|
elif active_tab == "request":
|
|
queryset = RequestEvent.objects.order_by("-datetime")
|
|
tab_title = _("HTTP Requests")
|
|
else:
|
|
queryset = CRUDEvent.objects.order_by("-datetime")
|
|
tab_title = _("Model Changes (CRUD)")
|
|
active_tab = "crud"
|
|
|
|
paginator = Paginator(queryset, logs_per_page)
|
|
page = request.GET.get("page")
|
|
|
|
try:
|
|
logs_page = paginator.page(page)
|
|
except PageNotAnInteger:
|
|
logs_page = paginator.page(1)
|
|
except EmptyPage:
|
|
logs_page = paginator.page(paginator.num_pages)
|
|
|
|
context = {
|
|
"logs": logs_page,
|
|
"total_count": queryset.count(),
|
|
"active_tab": active_tab,
|
|
"tab_title": tab_title,
|
|
}
|
|
|
|
return render(request, "includes/easy_logs.html", context)
|
|
|
|
|
|
from allauth.account.views import SignupView
|
|
from django.contrib.auth.decorators import user_passes_test
|
|
|
|
|
|
def is_superuser_check(user):
|
|
return user.is_superuser
|
|
|
|
|
|
@staff_user_required
|
|
def create_staff_user(request):
|
|
if request.method == "POST":
|
|
form = StaffUserCreationForm(request.POST)
|
|
if form.is_valid():
|
|
form.save()
|
|
messages.success(
|
|
request,
|
|
f"Staff user {form.cleaned_data['first_name']} {form.cleaned_data['last_name']} "
|
|
f"({form.cleaned_data['email']}) created successfully!",
|
|
)
|
|
return redirect("admin_settings")
|
|
else:
|
|
form = StaffUserCreationForm()
|
|
return render(request, "user/create_staff.html", {"form": form})
|
|
|
|
|
|
@staff_user_required
|
|
def admin_settings(request):
|
|
staffs = User.objects.filter(user_type="staff",is_superuser=False)
|
|
form = ToggleAccountForm()
|
|
context = {"staffs": staffs, "form": form}
|
|
return render(request, "user/admin_settings.html", context)
|
|
|
|
@staff_user_required
|
|
def staff_assignment_view(request, slug):
|
|
"""
|
|
View to assign staff to a job posting
|
|
"""
|
|
job = get_object_or_404(JobPosting, slug=slug)
|
|
staff_users = User.objects.filter(user_type="staff", is_superuser=False)
|
|
applications = job.applications.all()
|
|
|
|
if request.method == "POST":
|
|
form = StaffAssignmentForm(request.POST, instance=job)
|
|
|
|
if form.is_valid():
|
|
job.assigned_to = form.cleaned_data["assigned_to"]
|
|
job.save(update_fields=["assigned_to"])
|
|
messages.success(request, f"Staff assigned to job '{job.title}' successfully!")
|
|
return redirect("job_detail", slug=job.slug)
|
|
else:
|
|
messages.error(request, "Please correct the errors below.")
|
|
else:
|
|
form = StaffAssignmentForm(instance=job)
|
|
print(staff_users)
|
|
context = {
|
|
"job": job,
|
|
"applications": applications,
|
|
"staff_users": staff_users,
|
|
"form": form,
|
|
}
|
|
return render(request, "recruitment/staff_assignment_view.html", context)
|
|
|
|
|
|
from django.contrib.auth.forms import SetPasswordForm
|
|
|
|
|
|
@staff_user_required
|
|
def set_staff_password(request, pk):
|
|
user = get_object_or_404(User, pk=pk)
|
|
print(request.POST)
|
|
if request.method == "POST":
|
|
form = SetPasswordForm(user, data=request.POST)
|
|
if form.is_valid():
|
|
form.save()
|
|
messages.success(request, f"Password successfully changed")
|
|
return redirect("admin_settings")
|
|
else:
|
|
form = SetPasswordForm(user=user)
|
|
messages.error(request, f"Password does not match please try again.")
|
|
return redirect("admin_settings")
|
|
|
|
else:
|
|
form = SetPasswordForm(user=user)
|
|
return render(
|
|
request, "user/staff_password_create.html", {"form": form, "user": user}
|
|
)
|
|
|
|
|
|
@staff_user_required
|
|
def account_toggle_status(request, pk):
|
|
user = get_object_or_404(User, pk=pk)
|
|
if request.method == "POST":
|
|
print(user.is_active)
|
|
form = ToggleAccountForm(request.POST)
|
|
if form.is_valid():
|
|
if user.is_active:
|
|
user.is_active = False
|
|
user.save()
|
|
messages.success(
|
|
request, f"Staff with email: {user.email} deactivated successfully"
|
|
)
|
|
return redirect("admin_settings")
|
|
else:
|
|
user.is_active = True
|
|
user.save()
|
|
messages.success(
|
|
request, f"Staff with email: {user.email} activated successfully"
|
|
)
|
|
return redirect("admin_settings")
|
|
else:
|
|
messages.error(f"Please correct the error below")
|
|
|
|
|
|
# @login_required
|
|
# def user_detail(requests,pk):
|
|
# user=get_object_or_404(User,pk=pk)
|
|
# return render(requests,'user/profile.html')
|
|
|
|
|
|
@csrf_exempt
|
|
def zoom_webhook_view(request):
|
|
api_key = request.headers.get("X-Zoom-API-KEY")
|
|
if api_key != settings.ZOOM_WEBHOOK_API_KEY:
|
|
return HttpResponse(status=405)
|
|
|
|
if request.method == "POST":
|
|
try:
|
|
payload = json.loads(request.body)
|
|
async_task("recruitment.tasks.handle_zoom_webhook_event", payload)
|
|
return HttpResponse(status=200)
|
|
except Exception:
|
|
return HttpResponse(status=400)
|
|
return HttpResponse(status=405)
|
|
|
|
|
|
# Meeting Comments Views
|
|
@staff_user_required
|
|
def add_meeting_comment(request, slug):
|
|
"""Add a comment to a meeting"""
|
|
# from .forms import MeetingCommentForm
|
|
|
|
meeting = get_object_or_404(InterviewNote, slug=slug)
|
|
print(meeting)
|
|
|
|
if request.method == "POST":
|
|
form = InterviewNoteForm(request.POST)
|
|
if form.is_valid():
|
|
comment = form.save(commit=False)
|
|
comment.meeting = meeting
|
|
comment.author = request.user
|
|
comment.save()
|
|
messages.success(request, "Comment added successfully!")
|
|
|
|
# HTMX response - return just the comment section
|
|
if "HX-Request" in request.headers:
|
|
return render(
|
|
request,
|
|
"includes/comment_list.html",
|
|
{
|
|
"comments": meeting.comments.all().order_by("-created_at"),
|
|
"meeting": meeting,
|
|
},
|
|
)
|
|
|
|
return redirect("meeting_details", slug=slug)
|
|
else:
|
|
form = InterviewNoteForm()
|
|
|
|
context = {
|
|
"form": form,
|
|
"meeting": meeting,
|
|
}
|
|
|
|
# HTMX response - return the comment form
|
|
if "HX-Request" in request.headers:
|
|
return render(request, "includes/comment_form.html", context)
|
|
|
|
return redirect("meeting_details", slug=slug)
|
|
|
|
|
|
@staff_user_required
|
|
def edit_meeting_comment(request, slug, comment_id):
|
|
"""Edit a meeting comment"""
|
|
meeting = get_object_or_404(ZoomMeetingDetails, slug=slug)
|
|
comment = get_object_or_404(InterviewNote, id=comment_id, meeting=meeting)
|
|
|
|
# Check if user is author
|
|
if comment.author != request.user and not request.user.is_staff:
|
|
messages.error(request, "You can only edit your own comments.")
|
|
return redirect("meeting_details", slug=slug)
|
|
|
|
if request.method == "POST":
|
|
form = InterviewNoteForm(request.POST, instance=comment)
|
|
if form.is_valid():
|
|
comment = form.save()
|
|
messages.success(request, "Comment updated successfully!")
|
|
|
|
# HTMX response - return just comment section
|
|
if "HX-Request" in request.headers:
|
|
return render(
|
|
request,
|
|
"includes/comment_list.html",
|
|
{
|
|
"comments": meeting.comments.all().order_by("-created_at"),
|
|
"meeting": meeting,
|
|
},
|
|
)
|
|
|
|
return redirect("meeting_details", slug=slug)
|
|
else:
|
|
form = InterviewNoteForm(instance=comment)
|
|
|
|
context = {"form": form, "meeting": meeting, "comment": comment}
|
|
return render(request, "includes/edit_comment_form.html", context)
|
|
|
|
|
|
@staff_user_required
|
|
def delete_meeting_comment(request, slug, comment_id):
|
|
"""Delete a meeting comment"""
|
|
meeting = get_object_or_404(ZoomMeetingDetails, slug=slug)
|
|
comment = get_object_or_404(InterviewNote, id=comment_id, meeting=meeting)
|
|
|
|
# Check if user is the author
|
|
if comment.author != request.user and not request.user.is_staff:
|
|
messages.error(request, "You can only delete your own comments.")
|
|
return redirect("meeting_details", slug=slug)
|
|
|
|
if request.method == "POST":
|
|
comment.delete()
|
|
messages.success(request, "Comment deleted successfully!")
|
|
|
|
# HTMX response - return just the comment section
|
|
if "HX-Request" in request.headers:
|
|
return render(
|
|
request,
|
|
"includes/comment_list.html",
|
|
{
|
|
"comments": meeting.comments.all().order_by("-created_at"),
|
|
"meeting": meeting,
|
|
},
|
|
)
|
|
|
|
return redirect("meeting_details", slug=slug)
|
|
|
|
# HTMX response - return the delete confirmation modal
|
|
if "HX-Request" in request.headers:
|
|
return render(
|
|
request,
|
|
"includes/delete_comment_form.html",
|
|
{
|
|
"meeting": meeting,
|
|
"comment": comment,
|
|
"delete_url": reverse(
|
|
"delete_meeting_comment",
|
|
kwargs={"slug": slug, "comment_id": comment_id},
|
|
),
|
|
},
|
|
)
|
|
|
|
return redirect("meeting_details", slug=slug)
|
|
|
|
|
|
@staff_user_required
|
|
def set_meeting_candidate(request, slug):
|
|
meeting = get_object_or_404(ZoomMeetingDetails, slug=slug)
|
|
if request.method == "POST" and "HX-Request" not in request.headers:
|
|
form = InterviewForm(request.POST)
|
|
if form.is_valid():
|
|
candidate = form.save(commit=False)
|
|
candidate.zoom_meeting = meeting
|
|
candidate.interview_date = meeting.start_time.date()
|
|
candidate.interview_time = meeting.start_time.time()
|
|
candidate.save()
|
|
messages.success(request, "Candidate added successfully!")
|
|
return redirect("list_meetings")
|
|
job = request.GET.get("job")
|
|
form = InterviewForm()
|
|
|
|
if job:
|
|
form.fields["candidate"].queryset = Application.objects.filter(job=job)
|
|
|
|
else:
|
|
form.fields["candidate"].queryset = Application.objects.none()
|
|
form.fields["job"].widget.attrs.update(
|
|
{
|
|
"hx-get": reverse("set_meeting_candidate", kwargs={"slug": slug}),
|
|
"hx-target": "#div_id_candidate",
|
|
"hx-select": "#div_id_candidate",
|
|
"hx-swap": "outerHTML",
|
|
}
|
|
)
|
|
context = {"form": form, "meeting": meeting}
|
|
return render(request, "meetings/set_candidate_form.html", context)
|
|
|
|
|
|
# Hiring Agency CRUD Views
|
|
@staff_user_required
|
|
def agency_list(request):
|
|
"""List all hiring agencies with search and pagination"""
|
|
search_query = request.GET.get("search", "")
|
|
agencies = HiringAgency.objects.all()
|
|
|
|
if search_query:
|
|
agencies = agencies.filter(
|
|
Q(name__icontains=search_query)
|
|
| Q(contact_person__icontains=search_query)
|
|
| Q(email__icontains=search_query)
|
|
| Q(country__icontains=search_query)
|
|
)
|
|
|
|
# Order by most recently created
|
|
agencies = agencies.order_by("-created_at")
|
|
|
|
# Pagination
|
|
paginator = Paginator(agencies, 10) # Show 10 agencies per page
|
|
page_number = request.GET.get("page")
|
|
page_obj = paginator.get_page(page_number)
|
|
|
|
context = {
|
|
"page_obj": page_obj,
|
|
"search_query": search_query,
|
|
"total_agencies": agencies.count(),
|
|
}
|
|
return render(request, "recruitment/agency_list.html", context)
|
|
|
|
|
|
@staff_user_required
|
|
def agency_create(request):
|
|
"""Create a new hiring agency"""
|
|
if request.method == "POST":
|
|
form = HiringAgencyForm(request.POST)
|
|
if form.is_valid():
|
|
agency = form.save()
|
|
messages.success(request, f'Agency "{agency.name}" created successfully!')
|
|
return redirect("agency_detail", slug=agency.slug)
|
|
else:
|
|
messages.error(request, "Please correct the errors below.")
|
|
else:
|
|
form = HiringAgencyForm()
|
|
|
|
context = {
|
|
"form": form,
|
|
"title": _("Create New Agency"),
|
|
"button_text": _("Create Agency"),
|
|
}
|
|
return render(request, "recruitment/agency_form.html", context)
|
|
|
|
|
|
@staff_user_required
|
|
def agency_detail(request, slug):
|
|
"""View details of a specific hiring agency"""
|
|
agency = get_object_or_404(HiringAgency, slug=slug)
|
|
|
|
# Get candidates associated with this agency
|
|
candidates = Application.objects.filter(hiring_agency=agency).order_by(
|
|
"-created_at"
|
|
)
|
|
|
|
# Statistics
|
|
total_candidates = candidates.count()
|
|
active_candidates = candidates.filter(
|
|
stage__in=["Applied", "Screening", "Exam", "Interview", "Offer"]
|
|
).count()
|
|
hired_candidates = candidates.filter(stage="Hired").count()
|
|
rejected_candidates = candidates.filter(stage="Rejected").count()
|
|
|
|
context = {
|
|
"agency": agency,
|
|
"candidates": candidates[:10], # Show recent 10 candidates
|
|
"total_candidates": total_candidates,
|
|
"active_candidates": active_candidates,
|
|
"hired_candidates": hired_candidates,
|
|
"rejected_candidates": rejected_candidates,
|
|
"generated_password": agency.generated_password
|
|
if agency.generated_password
|
|
else None,
|
|
}
|
|
return render(request, "recruitment/agency_detail.html", context)
|
|
|
|
|
|
@staff_user_required
|
|
def agency_update(request, slug):
|
|
"""Update an existing hiring agency"""
|
|
agency = get_object_or_404(HiringAgency, slug=slug)
|
|
|
|
if request.method == "POST":
|
|
form = HiringAgencyForm(request.POST, instance=agency)
|
|
if form.is_valid():
|
|
agency = form.save()
|
|
messages.success(request, f'Agency "{agency.name}" updated successfully!')
|
|
return redirect("agency_detail", slug=agency.slug)
|
|
else:
|
|
messages.error(request, "Please correct the errors below.")
|
|
else:
|
|
form = HiringAgencyForm(instance=agency)
|
|
|
|
context = {
|
|
"form": form,
|
|
"agency": agency,
|
|
"title": f"Edit Agency: {agency.name}",
|
|
"button_text": _("Update Agency"),
|
|
}
|
|
return render(request, "recruitment/agency_form.html", context)
|
|
|
|
|
|
@staff_user_required
|
|
def agency_delete(request, slug):
|
|
"""Delete a hiring agency"""
|
|
agency = get_object_or_404(HiringAgency, slug=slug)
|
|
|
|
if request.method == "POST":
|
|
agency_name = agency.name
|
|
agency.delete()
|
|
messages.success(request, f'Agency "{agency_name}" deleted successfully!')
|
|
return redirect("agency_list")
|
|
|
|
context = {
|
|
"agency": agency,
|
|
"title": "Delete Agency",
|
|
"message": f'Are you sure you want to delete the agency "{agency.name}"?',
|
|
"cancel_url": reverse("agency_detail", kwargs={"slug": agency.slug}),
|
|
}
|
|
return render(request, "recruitment/agency_confirm_delete.html", context)
|
|
|
|
|
|
# Notification Views
|
|
# @staff_user_required
|
|
# def notification_list(request):
|
|
# """List all notifications for the current user"""
|
|
# # Get filter parameters
|
|
# status_filter = request.GET.get('status', '')
|
|
# type_filter = request.GET.get('type', '')
|
|
|
|
# # Base queryset
|
|
# notifications = Notification.objects.filter(recipient=request.user).order_by('-created_at')
|
|
|
|
# # Apply filters
|
|
# if status_filter:
|
|
# if status_filter == 'unread':
|
|
# notifications = notifications.filter(status=Notification.Status.PENDING)
|
|
# elif status_filter == 'read':
|
|
# notifications = notifications.filter(status=Notification.Status.READ)
|
|
# elif status_filter == 'sent':
|
|
# notifications = notifications.filter(status=Notification.Status.SENT)
|
|
|
|
# if type_filter:
|
|
# if type_filter == 'in_app':
|
|
# notifications = notifications.filter(notification_type=Notification.NotificationType.IN_APP)
|
|
# elif type_filter == 'email':
|
|
# notifications = notifications.filter(notification_type=Notification.NotificationType.EMAIL)
|
|
|
|
# # Pagination
|
|
# paginator = Paginator(notifications, 20) # Show 20 notifications per page
|
|
# page_number = request.GET.get('page')
|
|
# page_obj = paginator.get_page(page_number)
|
|
|
|
# # Statistics
|
|
# total_notifications = notifications.count()
|
|
# unread_notifications = notifications.filter(status=Notification.Status.PENDING).count()
|
|
# email_notifications = notifications.filter(notification_type=Notification.NotificationType.EMAIL).count()
|
|
|
|
# context = {
|
|
# 'page_obj': page_obj,
|
|
# 'total_notifications': total_notifications,
|
|
# 'unread_notifications': unread_notifications,
|
|
# 'email_notifications': email_notifications,
|
|
# 'status_filter': status_filter,
|
|
# 'type_filter': type_filter,
|
|
# }
|
|
# return render(request, 'recruitment/notification_list.html', context)
|
|
|
|
|
|
# @staff_user_required
|
|
# def notification_detail(request, notification_id):
|
|
# """View details of a specific notification"""
|
|
# notification = get_object_or_404(Notification, id=notification_id, recipient=request.user)
|
|
|
|
# # Mark as read if it was pending
|
|
# if notification.status == Notification.Status.PENDING:
|
|
# notification.status = Notification.Status.READ
|
|
# notification.save(update_fields=['status'])
|
|
|
|
# context = {
|
|
# 'notification': notification,
|
|
# }
|
|
# return render(request, 'recruitment/notification_detail.html', context)
|
|
|
|
|
|
# @staff_user_required
|
|
# def notification_mark_read(request, notification_id):
|
|
# """Mark a notification as read"""
|
|
# notification = get_object_or_404(Notification, id=notification_id, recipient=request.user)
|
|
|
|
# if notification.status == Notification.Status.PENDING:
|
|
# notification.status = Notification.Status.READ
|
|
# notification.save(update_fields=['status'])
|
|
|
|
# if 'HX-Request' in request.headers:
|
|
# return HttpResponse(status=200) # HTMX success response
|
|
|
|
# return redirect('notification_list')
|
|
|
|
|
|
# @staff_user_required
|
|
# def notification_mark_unread(request, notification_id):
|
|
# """Mark a notification as unread"""
|
|
# notification = get_object_or_404(Notification, id=notification_id, recipient=request.user)
|
|
|
|
# if notification.status == Notification.Status.READ:
|
|
# notification.status = Notification.Status.PENDING
|
|
# notification.save(update_fields=['status'])
|
|
|
|
# if 'HX-Request' in request.headers:
|
|
# return HttpResponse(status=200) # HTMX success response
|
|
|
|
# return redirect('notification_list')
|
|
|
|
|
|
# @staff_user_required
|
|
# def notification_delete(request, notification_id):
|
|
# """Delete a notification"""
|
|
# notification = get_object_or_404(Notification, id=notification_id, recipient=request.user)
|
|
|
|
# if request.method == 'POST':
|
|
# notification.delete()
|
|
# messages.success(request, 'Notification deleted successfully!')
|
|
# return redirect('notification_list')
|
|
|
|
# # For GET requests, show confirmation page
|
|
# context = {
|
|
# 'notification': notification,
|
|
# 'title': 'Delete Notification',
|
|
# 'message': f'Are you sure you want to delete this notification?',
|
|
# 'cancel_url': reverse('notification_detail', kwargs={'notification_id': notification.id}),
|
|
# }
|
|
# return render(request, 'recruitment/notification_confirm_delete.html', context)
|
|
|
|
|
|
# @staff_user_required
|
|
# def notification_mark_all_read(request):
|
|
# """Mark all notifications as read for the current user"""
|
|
# if request.method == 'POST':
|
|
# Notification.objects.filter(
|
|
# recipient=request.user,
|
|
# status=Notification.Status.PENDING
|
|
# ).update(status=Notification.Status.READ)
|
|
|
|
# messages.success(request, 'All notifications marked as read!')
|
|
# return redirect('notification_list')
|
|
|
|
# # For GET requests, show confirmation page
|
|
# unread_count = Notification.objects.filter(
|
|
# recipient=request.user,
|
|
# status=Notification.Status.PENDING
|
|
# ).count()
|
|
|
|
# context = {
|
|
# 'unread_count': unread_count,
|
|
# 'title': 'Mark All as Read',
|
|
# 'message': f'Are you sure you want to mark all {unread_count} notifications as read?',
|
|
# 'cancel_url': reverse('notification_list'),
|
|
# }
|
|
# return render(request, 'recruitment/notification_confirm_all_read.html', context)
|
|
|
|
|
|
# @staff_user_required
|
|
# def api_notification_count(request):
|
|
# """API endpoint to get unread notification count and recent notifications"""
|
|
# # Get unread notifications
|
|
# unread_notifications = Notification.objects.filter(
|
|
# recipient=request.user,
|
|
# status=Notification.Status.PENDING
|
|
# ).order_by('-created_at')
|
|
|
|
# # Get recent notifications (last 5)
|
|
# recent_notifications = Notification.objects.filter(
|
|
# recipient=request.user
|
|
# ).order_by('-created_at')[:5]
|
|
|
|
# # Prepare recent notifications data
|
|
# recent_data = []
|
|
# for notification in recent_notifications:
|
|
# time_ago = ''
|
|
# if notification.created_at:
|
|
# from datetime import datetime, timezone
|
|
# now = timezone.now()
|
|
# diff = now - notification.created_at
|
|
|
|
# if diff.days > 0:
|
|
# time_ago = f'{diff.days}d ago'
|
|
# elif diff.seconds > 3600:
|
|
# hours = diff.seconds // 3600
|
|
# time_ago = f'{hours}h ago'
|
|
# elif diff.seconds > 60:
|
|
# minutes = diff.seconds // 60
|
|
# time_ago = f'{minutes}m ago'
|
|
# else:
|
|
# time_ago = 'Just now'
|
|
|
|
# recent_data.append({
|
|
# 'id': notification.id,
|
|
# 'message': notification.message[:100] + ('...' if len(notification.message) > 100 else ''),
|
|
# 'type': notification.get_notification_type_display(),
|
|
# 'status': notification.get_status_display(),
|
|
# 'time_ago': time_ago,
|
|
# 'url': reverse('notification_detail', kwargs={'notification_id': notification.id})
|
|
# })
|
|
|
|
# return JsonResponse({
|
|
# 'count': unread_notifications.count(),
|
|
# 'recent_notifications': recent_data
|
|
# })
|
|
|
|
|
|
# @staff_user_required
|
|
# def notification_stream(request):
|
|
# """SSE endpoint for real-time notifications"""
|
|
# from django.http import StreamingHttpResponse
|
|
# import json
|
|
# import time
|
|
# from .signals import SSE_NOTIFICATION_CACHE
|
|
|
|
# def event_stream():
|
|
# """Generator function for SSE events"""
|
|
# user_id = request.user.id
|
|
# last_notification_id = 0
|
|
|
|
# # Get initial last notification ID
|
|
# last_notification = Notification.objects.filter(
|
|
# recipient=request.user
|
|
# ).order_by('-id').first()
|
|
# if last_notification:
|
|
# last_notification_id = last_notification.id
|
|
|
|
# # Send any cached notifications first
|
|
# cached_notifications = SSE_NOTIFICATION_CACHE.get(user_id, [])
|
|
# for cached_notification in cached_notifications:
|
|
# if cached_notification['id'] > last_notification_id:
|
|
# yield f"event: new_notification\n"
|
|
# yield f"data: {json.dumps(cached_notification)}\n\n"
|
|
# last_notification_id = cached_notification['id']
|
|
|
|
# while True:
|
|
# try:
|
|
# # Check for new notifications from cache first
|
|
# cached_notifications = SSE_NOTIFICATION_CACHE.get(user_id, [])
|
|
# new_cached = [n for n in cached_notifications if n['id'] > last_notification_id]
|
|
|
|
# for notification_data in new_cached:
|
|
# yield f"event: new_notification\n"
|
|
# yield f"data: {json.dumps(notification_data)}\n\n"
|
|
# last_notification_id = notification_data['id']
|
|
|
|
# # Also check database for any missed notifications
|
|
# new_notifications = Notification.objects.filter(
|
|
# recipient=request.user,
|
|
# id__gt=last_notification_id
|
|
# ).order_by('id')
|
|
|
|
# if new_notifications.exists():
|
|
# for notification in new_notifications:
|
|
# # Prepare notification data
|
|
# time_ago = ''
|
|
# if notification.created_at:
|
|
# now = timezone.now()
|
|
# diff = now - notification.created_at
|
|
|
|
# if diff.days > 0:
|
|
# time_ago = f'{diff.days}d ago'
|
|
# elif diff.seconds > 3600:
|
|
# hours = diff.seconds // 3600
|
|
# time_ago = f'{hours}h ago'
|
|
# elif diff.seconds > 60:
|
|
# minutes = diff.seconds // 60
|
|
# time_ago = f'{minutes}m ago'
|
|
# else:
|
|
# time_ago = 'Just now'
|
|
|
|
# notification_data = {
|
|
# 'id': notification.id,
|
|
# 'message': notification.message[:100] + ('...' if len(notification.message) > 100 else ''),
|
|
# 'type': notification.get_notification_type_display(),
|
|
# 'status': notification.get_status_display(),
|
|
# 'time_ago': time_ago,
|
|
# 'url': reverse('notification_detail', kwargs={'notification_id': notification.id})
|
|
# }
|
|
|
|
# # Send SSE event
|
|
# yield f"event: new_notification\n"
|
|
# yield f"data: {json.dumps(notification_data)}\n\n"
|
|
|
|
# last_notification_id = notification.id
|
|
|
|
# # Update count after sending new notifications
|
|
# unread_count = Notification.objects.filter(
|
|
# recipient=request.user,
|
|
# status=Notification.Status.PENDING
|
|
# ).count()
|
|
|
|
# count_data = {'count': unread_count}
|
|
# yield f"event: count_update\n"
|
|
# yield f"data: {json.dumps(count_data)}\n\n"
|
|
|
|
# # Send heartbeat every 30 seconds
|
|
# yield f"event: heartbeat\n"
|
|
# yield f"data: {json.dumps({'timestamp': int(time.time())})}\n\n"
|
|
|
|
# # Wait before next check
|
|
# time.sleep(5) # Check every 5 seconds
|
|
|
|
# except Exception as e:
|
|
# # Send error event and continue
|
|
# error_data = {'error': str(e)}
|
|
# yield f"event: error\n"
|
|
# yield f"data: {json.dumps(error_data)}\n\n"
|
|
# time.sleep(10) # Wait longer on error
|
|
|
|
# response = StreamingHttpResponse(
|
|
# event_stream(),
|
|
# content_type='text/event-stream'
|
|
# )
|
|
|
|
# # Set SSE headers
|
|
# response['Cache-Control'] = 'no-cache'
|
|
# response['X-Accel-Buffering'] = 'no' # Disable buffering for nginx
|
|
# response['Connection'] = 'keep-alive'
|
|
|
|
# context = {
|
|
# 'agency': agency,
|
|
# 'page_obj': page_obj,
|
|
# 'stage_filter': stage_filter,
|
|
# 'total_candidates': candidates.count(),
|
|
# }
|
|
# return render(request, 'recruitment/agency_candidates.html', context)
|
|
|
|
|
|
@staff_user_required
|
|
def agency_candidates(request, slug):
|
|
"""View all candidates from a specific agency"""
|
|
agency = get_object_or_404(HiringAgency, slug=slug)
|
|
candidates = Application.objects.filter(hiring_agency=agency).order_by(
|
|
"-created_at"
|
|
)
|
|
|
|
# Filter by stage if provided
|
|
stage_filter = request.GET.get("stage")
|
|
if stage_filter:
|
|
candidates = candidates.filter(stage=stage_filter)
|
|
|
|
# Get total candidates before pagination for accurate count
|
|
total_candidates = candidates.count()
|
|
|
|
# Pagination
|
|
paginator = Paginator(candidates, 20) # Show 20 candidates per page
|
|
page_number = request.GET.get("page")
|
|
page_obj = paginator.get_page(page_number)
|
|
|
|
context = {
|
|
"agency": agency,
|
|
"page_obj": page_obj,
|
|
"stage_filter": stage_filter,
|
|
"total_candidates": total_candidates,
|
|
}
|
|
return render(request, "recruitment/agency_candidates.html", context)
|
|
|
|
|
|
# Agency Portal Management Views
|
|
@staff_user_required
|
|
def agency_assignment_list(request):
|
|
"""List all agency job assignments"""
|
|
search_query = request.GET.get("q", "")
|
|
status_filter = request.GET.get("status", "")
|
|
|
|
assignments = AgencyJobAssignment.objects.select_related("agency", "job").order_by(
|
|
"-created_at"
|
|
)
|
|
|
|
if search_query:
|
|
assignments = assignments.filter(
|
|
Q(agency__name__icontains=search_query)
|
|
| Q(job__title__icontains=search_query)
|
|
)
|
|
|
|
if status_filter:
|
|
assignments = assignments.filter(status=status_filter)
|
|
|
|
# Pagination
|
|
paginator = Paginator(assignments, 15) # Show 15 assignments per page
|
|
page_number = request.GET.get("page")
|
|
page_obj = paginator.get_page(page_number)
|
|
|
|
context = {
|
|
"page_obj": page_obj,
|
|
"search_query": search_query,
|
|
"status_filter": status_filter,
|
|
"total_assignments": assignments.count(),
|
|
}
|
|
return render(request, "recruitment/agency_assignment_list.html", context)
|
|
|
|
|
|
@staff_user_required
|
|
def agency_assignment_create(request, slug=None):
|
|
"""Create a new agency job assignment"""
|
|
agency = HiringAgency.objects.get(slug=slug) if slug else None
|
|
|
|
if request.method == "POST":
|
|
form = AgencyJobAssignmentForm(request.POST)
|
|
# if agency:
|
|
# form.instance.agency = agency
|
|
if form.is_valid():
|
|
assignment = form.save()
|
|
messages.success(
|
|
request,
|
|
f"Assignment created for {assignment.agency.name} - {assignment.job.title}!",
|
|
)
|
|
return redirect("agency_assignment_detail", slug=assignment.slug)
|
|
else:
|
|
messages.error(
|
|
request, f"Please correct the errors below.{form.errors.as_text()}"
|
|
)
|
|
print(form.errors.as_json())
|
|
else:
|
|
form = AgencyJobAssignmentForm()
|
|
try:
|
|
# from django.forms import HiddenInput
|
|
form.initial["agency"] = agency
|
|
# form.fields['agency'].widget = HiddenInput()
|
|
except HiringAgency.DoesNotExist:
|
|
pass
|
|
|
|
context = {
|
|
"form": form,
|
|
"title": "Create New Assignment",
|
|
"button_text": "Create Assignment",
|
|
}
|
|
return render(request, "recruitment/agency_assignment_form.html", context)
|
|
|
|
|
|
@staff_user_required
|
|
def agency_assignment_detail(request, slug):
|
|
"""View details of a specific agency assignment"""
|
|
assignment = get_object_or_404(
|
|
AgencyJobAssignment.objects.select_related("agency", "job"), slug=slug
|
|
)
|
|
|
|
# Get candidates submitted by this agency for this job
|
|
candidates = Application.objects.filter(
|
|
hiring_agency=assignment.agency, job=assignment.job
|
|
).order_by("-created_at")
|
|
|
|
# Get access link if exists
|
|
access_link = getattr(assignment, "access_link", None)
|
|
|
|
# Get messages for this assignment
|
|
|
|
total_candidates = candidates.count()
|
|
max_candidates = assignment.max_candidates
|
|
circumference = 326.73 # 2 * π * r where r=52
|
|
|
|
if max_candidates > 0:
|
|
progress_percentage = total_candidates / max_candidates
|
|
stroke_dashoffset = circumference - (circumference * progress_percentage)
|
|
else:
|
|
stroke_dashoffset = circumference
|
|
|
|
context = {
|
|
"assignment": assignment,
|
|
"candidates": candidates,
|
|
"access_link": access_link,
|
|
"total_candidates": candidates.count(),
|
|
"stroke_dashoffset": stroke_dashoffset,
|
|
}
|
|
return render(request, "recruitment/agency_assignment_detail.html", context)
|
|
|
|
|
|
@staff_user_required
|
|
def agency_assignment_update(request, slug):
|
|
"""Update an existing agency assignment"""
|
|
assignment = get_object_or_404(AgencyJobAssignment, slug=slug)
|
|
|
|
if request.method == "POST":
|
|
form = AgencyJobAssignmentForm(request.POST, instance=assignment)
|
|
if form.is_valid():
|
|
assignment = form.save()
|
|
messages.success(request, f"Assignment updated successfully!")
|
|
return redirect("agency_assignment_detail", slug=assignment.slug)
|
|
else:
|
|
messages.error(request, "Please correct the errors below.")
|
|
else:
|
|
form = AgencyJobAssignmentForm(instance=assignment)
|
|
|
|
context = {
|
|
"form": form,
|
|
"assignment": assignment,
|
|
"title": f"Edit Assignment: {assignment.agency.name} - {assignment.job.title}",
|
|
"button_text": "Update Assignment",
|
|
}
|
|
return render(request, "recruitment/agency_assignment_form.html", context)
|
|
|
|
|
|
@staff_user_required
|
|
def agency_access_link_create(request):
|
|
"""Create access link for agency assignment"""
|
|
if request.method == "POST":
|
|
form = AgencyAccessLinkForm(request.POST)
|
|
if form.is_valid():
|
|
access_link = form.save()
|
|
messages.success(
|
|
request,
|
|
f"Access link created for {access_link.assignment.agency.name}!",
|
|
)
|
|
return redirect(
|
|
"agency_assignment_detail", slug=access_link.assignment.slug
|
|
)
|
|
else:
|
|
messages.error(request, "Please correct the errors below.")
|
|
else:
|
|
form = AgencyAccessLinkForm()
|
|
|
|
context = {
|
|
"form": form,
|
|
"title": "Create Access Link",
|
|
"button_text": "Create Link",
|
|
}
|
|
return render(request, "recruitment/agency_access_link_form.html", context)
|
|
|
|
|
|
@staff_user_required
|
|
def agency_access_link_detail(request, slug):
|
|
"""View details of an access link"""
|
|
access_link = get_object_or_404(
|
|
AgencyAccessLink.objects.select_related(
|
|
"assignment__agency", "assignment__job"
|
|
),
|
|
slug=slug,
|
|
)
|
|
|
|
context = {
|
|
"access_link": access_link,
|
|
}
|
|
return render(request, "recruitment/agency_access_link_detail.html", context)
|
|
|
|
|
|
@staff_user_required
|
|
def agency_assignment_extend_deadline(request, slug):
|
|
"""Extend deadline for an agency assignment"""
|
|
assignment = get_object_or_404(AgencyJobAssignment, slug=slug)
|
|
|
|
if request.method == "POST":
|
|
new_deadline = request.POST.get("new_deadline")
|
|
if new_deadline:
|
|
try:
|
|
from datetime import datetime
|
|
|
|
new_deadline_dt = datetime.fromisoformat(
|
|
new_deadline.replace("Z", "+00:00")
|
|
)
|
|
# Ensure the new deadline is timezone-aware
|
|
if timezone.is_naive(new_deadline_dt):
|
|
new_deadline_dt = timezone.make_aware(new_deadline_dt)
|
|
|
|
if assignment.extend_deadline(new_deadline_dt):
|
|
messages.success(
|
|
request,
|
|
f"Deadline extended to {new_deadline_dt.strftime('%Y-%m-%d %H:%M')}!",
|
|
)
|
|
else:
|
|
messages.error(
|
|
request, "New deadline must be later than current deadline."
|
|
)
|
|
except ValueError:
|
|
messages.error(request, "Invalid date format.")
|
|
else:
|
|
messages.error(request, "Please provide a new deadline.")
|
|
|
|
return redirect("agency_assignment_detail", slug=assignment.slug)
|
|
|
|
|
|
|
|
@require_POST
|
|
def portal_password_reset(request,pk):
|
|
user = get_object_or_404(User, pk=pk)
|
|
if request.method == 'POST':
|
|
form = PasswordResetForm(request.POST)
|
|
if form.is_valid():
|
|
# Verify old password
|
|
old_password = form.cleaned_data['old_password']
|
|
if not user.check_password(old_password):
|
|
messages.error(request, 'Old password is incorrect.')
|
|
return redirect('user_detail', pk=user.pk)
|
|
|
|
# Set new password
|
|
user.set_password(form.cleaned_data['new_password1'])
|
|
user.save()
|
|
messages.success(request, 'Password reset successfully.')
|
|
return redirect('user_detail',pk=user.pk)
|
|
else:
|
|
for field, errors in form.errors.items():
|
|
for error in errors:
|
|
messages.error(request, f"{field}: {error}")
|
|
|
|
# Agency Portal Views (for external agencies)
|
|
def agency_portal_login(request):
|
|
"""Agency login page"""
|
|
# if request.session.get("agency_assignment_id"):
|
|
# return redirect("agency_portal_dashboard")
|
|
if request.method == "POST":
|
|
form = AgencyLoginForm(request.POST)
|
|
|
|
if form.is_valid():
|
|
# Check if validated_access_link attribute exists
|
|
|
|
# if hasattr(form, "validated_access_link"):
|
|
# access_link = form.validated_access_link
|
|
# access_link.record_access()
|
|
|
|
# Store assignment in session
|
|
# request.session["agency_assignment_id"] = access_link.assignment.id
|
|
# request.session["agency_name"] = access_link.assignment.agency.name
|
|
|
|
messages.success(request, f"Welcome, {access_link.assignment.agency.name}!")
|
|
return redirect("agency_portal_dashboard")
|
|
else:
|
|
messages.error(request, "Invalid token or password.")
|
|
else:
|
|
form = AgencyLoginForm()
|
|
|
|
context = {
|
|
"form": form,
|
|
}
|
|
return render(request, "recruitment/agency_portal_login.html", context)
|
|
|
|
|
|
def portal_login(request):
|
|
"""Unified portal login for agency and candidate"""
|
|
if request.user.is_authenticated:
|
|
if request.user.user_type == "agency":
|
|
return redirect("agency_portal_dashboard")
|
|
if request.user.user_type == "candidate":
|
|
print(request.user)
|
|
return redirect("candidate_portal_dashboard")
|
|
|
|
if request.method == "POST":
|
|
form = PortalLoginForm(request.POST)
|
|
|
|
if form.is_valid():
|
|
email = form.cleaned_data["email"]
|
|
password = form.cleaned_data["password"]
|
|
user_type = form.cleaned_data["user_type"]
|
|
|
|
# Authenticate user
|
|
user = authenticate(request, username=email, password=password)
|
|
if user is not None:
|
|
# Check if user type matches
|
|
if hasattr(user, "user_type") and user.user_type == user_type:
|
|
login(request, user)
|
|
return redirect("agency_portal_dashboard")
|
|
|
|
# if user_type == "agency":
|
|
# # Check if user has agency profile
|
|
# if hasattr(user, "agency_profile") and user.agency_profile:
|
|
# messages.success(
|
|
# request, f"Welcome, {user.agency_profile.name}!"
|
|
# )
|
|
# return redirect("agency_portal_dashboard")
|
|
# else:
|
|
# messages.error(
|
|
# request, "No agency profile found for this user."
|
|
# )
|
|
# logout(request)
|
|
|
|
# elif user_type == "candidate":
|
|
# # Check if user has candidate profile
|
|
# if (
|
|
# hasattr(user, "candidate_profile")
|
|
# and user.candidate_profile
|
|
# ):
|
|
# messages.success(
|
|
# request,
|
|
# f"Welcome, {user.candidate_profile.first_name}!",
|
|
# )
|
|
# return redirect("candidate_portal_dashboard")
|
|
# else:
|
|
# messages.error(
|
|
# request, "No candidate profile found for this user."
|
|
# )
|
|
# logout(request)
|
|
else:
|
|
messages.error(request, "Invalid user type selected.")
|
|
else:
|
|
messages.error(request, "Invalid email or password.")
|
|
else:
|
|
messages.error(request, "Please correct the errors below.")
|
|
else:
|
|
form = PortalLoginForm()
|
|
|
|
context = {
|
|
"form": form,
|
|
}
|
|
return render(request, "recruitment/portal_login.html", context)
|
|
|
|
|
|
|
|
def candidate_portal_dashboard(request):
|
|
"""Candidate portal dashboard"""
|
|
if not request.user.is_authenticated:
|
|
return redirect("account_login")
|
|
|
|
# Get candidate profile (Person record)
|
|
try:
|
|
candidate = request.user.person_profile
|
|
except:
|
|
messages.error(request, "No candidate profile found.")
|
|
return redirect("account_login")
|
|
|
|
# Get candidate's applications with related job data
|
|
applications = Application.objects.filter(
|
|
person=candidate
|
|
).select_related('job').order_by('-created_at')
|
|
|
|
# Get candidate's documents using the Person documents property
|
|
documents = candidate.documents.order_by('-created_at')
|
|
|
|
# Add password change form for modal
|
|
password_form = PasswordResetForm()
|
|
|
|
# Add document upload form for modal
|
|
from .forms import DocumentUploadForm
|
|
document_form = DocumentUploadForm()
|
|
|
|
context = {
|
|
"candidate": candidate,
|
|
"applications": applications,
|
|
"documents": documents,
|
|
"password_form": password_form,
|
|
"document_form": document_form,
|
|
}
|
|
return render(request, "recruitment/candidate_profile.html", context)
|
|
|
|
|
|
@login_required
|
|
def candidate_application_detail(request, slug):
|
|
"""View detailed information about a specific application"""
|
|
if not request.user.is_authenticated:
|
|
return redirect("account_login")
|
|
|
|
# Get candidate profile (Person record)
|
|
agency = getattr(request.user,"agency_profile",None)
|
|
if agency:
|
|
candidate = get_object_or_404(Application,slug=slug)
|
|
# if Application.objects.filter(person=candidate,hirin).exists()
|
|
else:
|
|
try:
|
|
candidate = request.user.person_profile
|
|
except:
|
|
messages.error(request, "No candidate profile found.")
|
|
return redirect("account_login")
|
|
|
|
# Get the specific application and verify it belongs to this candidate
|
|
application = get_object_or_404(
|
|
Application.objects.select_related(
|
|
'job', 'person'
|
|
).prefetch_related(
|
|
'scheduled_interviews' # Only prefetch interviews, not documents (Generic FK)
|
|
),
|
|
slug=slug,
|
|
person=candidate.person if agency else candidate
|
|
)
|
|
|
|
# Get AI analysis data if available
|
|
ai_analysis = None
|
|
if application.ai_analysis_data:
|
|
try:
|
|
ai_analysis = application.ai_analysis_data.get('analysis_data', {})
|
|
except (AttributeError, KeyError):
|
|
ai_analysis = {}
|
|
|
|
# Get interview details
|
|
interviews = application.scheduled_interviews.all().order_by('-created_at')
|
|
|
|
# Get documents
|
|
documents = application.documents.all().order_by('-created_at')
|
|
|
|
context = {
|
|
"application": application,
|
|
"candidate": candidate,
|
|
"ai_analysis": ai_analysis,
|
|
"interviews": interviews,
|
|
"documents": documents,
|
|
}
|
|
return render(request, "recruitment/candidate_application_detail.html", context)
|
|
|
|
|
|
@agency_user_required
|
|
def agency_portal_persons_list(request):
|
|
"""Agency portal page showing all persons who come through this agency"""
|
|
try:
|
|
agency = request.user.agency_profile
|
|
except Exception as e:
|
|
print(e)
|
|
messages.error(request, "No agency profile found.")
|
|
return redirect("account_login")
|
|
|
|
# Get all applications for this agency
|
|
persons = Person.objects.filter(agency=agency)
|
|
# persons = Application.objects.filter(
|
|
# hiring_agency=agency
|
|
# ).select_related("job").order_by("-created_at")
|
|
|
|
# Search functionality
|
|
search_query = request.GET.get("q", "")
|
|
if search_query:
|
|
persons = persons.filter(
|
|
Q(first_name__icontains=search_query)
|
|
| Q(last_name__icontains=search_query)
|
|
| Q(email__icontains=search_query)
|
|
| Q(phone__icontains=search_query)
|
|
| Q(job__title__icontains=search_query)
|
|
)
|
|
|
|
# Filter by stage if provided
|
|
stage_filter = request.GET.get("stage", "")
|
|
if stage_filter:
|
|
persons = persons.filter(stage=stage_filter)
|
|
|
|
# Pagination
|
|
paginator = Paginator(persons, 20) # Show 20 persons per page
|
|
page_number = request.GET.get("page")
|
|
page_obj = paginator.get_page(page_number)
|
|
|
|
# Get stage choices for filter dropdown
|
|
stage_choices = Application.Stage.choices
|
|
person_form = PersonForm()
|
|
person_form.initial["agency"] = agency
|
|
|
|
context = {
|
|
"agency": agency,
|
|
"page_obj": page_obj,
|
|
"search_query": search_query,
|
|
"stage_filter": stage_filter,
|
|
"stage_choices": stage_choices,
|
|
"total_persons": persons.count(),
|
|
"person_form": person_form,
|
|
}
|
|
return render(request, "recruitment/agency_portal_persons_list.html", context)
|
|
|
|
|
|
@agency_user_required
|
|
def agency_portal_dashboard(request):
|
|
"""Agency portal dashboard showing all assignments for the agency"""
|
|
# Get the current assignment to determine the agency
|
|
try:
|
|
agency = request.user.agency_profile
|
|
except Exception as e:
|
|
print(e)
|
|
messages.error(request, "No agency profile found.")
|
|
return redirect("portal_login")
|
|
|
|
# Get ALL assignments for this agency
|
|
assignments = (
|
|
AgencyJobAssignment.objects.filter(agency=agency)
|
|
.select_related("job")
|
|
.order_by("-created_at")
|
|
)
|
|
current_assignment = assignments.filter(is_active=True).first()
|
|
|
|
# Calculate statistics for each assignment
|
|
assignment_stats = []
|
|
for assignment in assignments:
|
|
candidates = Application.objects.filter(
|
|
hiring_agency=agency, job=assignment.job
|
|
).order_by("-created_at")
|
|
|
|
unread_messages = 0
|
|
|
|
assignment_stats.append(
|
|
{
|
|
"assignment": assignment,
|
|
"candidates": candidates,
|
|
"candidate_count": candidates.count(),
|
|
"unread_messages": unread_messages,
|
|
"days_remaining": assignment.days_remaining,
|
|
"is_active": assignment.is_currently_active,
|
|
"can_submit": assignment.can_submit,
|
|
}
|
|
)
|
|
|
|
# Get overall statistics
|
|
total_candidates = sum(stats["candidate_count"] for stats in assignment_stats)
|
|
total_unread_messages = sum(stats["unread_messages"] for stats in assignment_stats)
|
|
active_assignments = sum(1 for stats in assignment_stats if stats["is_active"])
|
|
|
|
context = {
|
|
"agency": agency,
|
|
"current_assignment": current_assignment,
|
|
"assignment_stats": assignment_stats,
|
|
"total_assignments": assignments.count(),
|
|
"active_assignments": active_assignments,
|
|
"total_candidates": total_candidates,
|
|
"total_unread_messages": total_unread_messages,
|
|
}
|
|
return render(request, "recruitment/agency_portal_dashboard.html", context)
|
|
|
|
|
|
@agency_user_required
|
|
def agency_portal_submit_candidate_page(request, slug):
|
|
"""Dedicated page for submitting a candidate"""
|
|
# assignment_id = request.session.get("agency_assignment_id")
|
|
# if not assignment_id:
|
|
# return redirect("agency_portal_login")
|
|
|
|
# Get the specific assignment by slug and verify it belongs to the same agency
|
|
# current_assignment = get_object_or_404(
|
|
# AgencyJobAssignment.objects.select_related("agency"), slug=slug
|
|
# )
|
|
assignment = get_object_or_404(
|
|
AgencyJobAssignment.objects.select_related("agency", "job"), slug=slug
|
|
)
|
|
current_agency=assignment.agency
|
|
current_job=assignment.job
|
|
|
|
if assignment.is_full:
|
|
messages.error(request, "Maximum candidate limit reached for this assignment.")
|
|
return redirect("agency_portal_assignment_detail", slug=assignment.slug)
|
|
# Verify this assignment belongs to the same agency as the logged-in session
|
|
if assignment.agency.id != assignment.agency.id:
|
|
messages.error(
|
|
request, "Access denied: This assignment does not belong to your agency."
|
|
)
|
|
return redirect("agency_portal_dashboard")
|
|
|
|
# Check if assignment allows submission
|
|
if not assignment.can_submit:
|
|
messages.error(
|
|
request,
|
|
"Cannot submit candidates: Assignment is not active, expired, or full.",
|
|
)
|
|
return redirect("agency_portal_assignment_detail", slug=assignment.slug)
|
|
|
|
# Get total submitted candidates for this assignment
|
|
total_submitted = Application.objects.filter(
|
|
hiring_agency=assignment.agency, job=assignment.job
|
|
).count()
|
|
|
|
form = ApplicationForm(current_agency=current_agency,current_job=current_job)
|
|
if request.method == "POST":
|
|
form = ApplicationForm(request.POST, request.FILES,current_agency=current_agency,current_job=current_job)
|
|
if form.is_valid():
|
|
candidate = form.save(commit=False)
|
|
|
|
candidate.hiring_source = "AGENCY"
|
|
candidate.hiring_agency = assignment.agency
|
|
candidate.save()
|
|
assignment.increment_submission_count()
|
|
return redirect("agency_portal_dashboard")
|
|
|
|
form.fields["hiring_agency"].initial = assignment.agency.id
|
|
form.fields["hiring_source"].initial = "Agency"
|
|
|
|
form.fields["hiring_agency"].widget = HiddenInput()
|
|
form.fields["hiring_source"].widget = HiddenInput()
|
|
|
|
context = {
|
|
"form": form,
|
|
"assignment": assignment,
|
|
"total_submitted": total_submitted,
|
|
"job": assignment.job,
|
|
}
|
|
return render(request, "recruitment/agency_portal_submit_candidate.html", context)
|
|
|
|
|
|
@agency_user_required
|
|
def agency_portal_submit_candidate(request):
|
|
"""Handle candidate submission via AJAX (for embedded form)"""
|
|
assignment_id = request.session.get("agency_assignment_id")
|
|
if not assignment_id:
|
|
return redirect("agency_portal_login")
|
|
|
|
assignment = get_object_or_404(
|
|
AgencyJobAssignment.objects.select_related("agency", "job"), id=assignment_id
|
|
)
|
|
if assignment.is_full:
|
|
messages.error(request, "Maximum candidate limit reached for this assignment.")
|
|
return redirect("agency_portal_assignment_detail", slug=assignment.slug)
|
|
|
|
# Check if assignment allows submission
|
|
if not assignment.can_submit:
|
|
messages.error(
|
|
request,
|
|
"Cannot submit candidates: Assignment is not active, expired, or full.",
|
|
)
|
|
return redirect("agency_portal_dashboard")
|
|
|
|
if request.method == "POST":
|
|
form = AgencyApplicationSubmissionForm(assignment, request.POST, request.FILES)
|
|
if form.is_valid():
|
|
candidate = form.save(commit=False)
|
|
candidate.hiring_source = "AGENCY"
|
|
candidate.hiring_agency = assignment.agency
|
|
candidate.save()
|
|
|
|
# Increment the assignment's submitted count
|
|
assignment.increment_submission_count()
|
|
|
|
if request.headers.get("X-Requested-With") == "XMLHttpRequest":
|
|
return JsonResponse(
|
|
{
|
|
"success": True,
|
|
"message": f"Candidate {candidate.name} submitted successfully!",
|
|
}
|
|
)
|
|
else:
|
|
messages.success(
|
|
request, f"Candidate {candidate.name} submitted successfully!"
|
|
)
|
|
return redirect("agency_portal_dashboard")
|
|
else:
|
|
if request.headers.get("X-Requested-With") == "XMLHttpRequest":
|
|
return JsonResponse(
|
|
{"success": False, "message": "Please correct the errors below."}
|
|
)
|
|
else:
|
|
messages.error(request, "Please correct errors below.")
|
|
else:
|
|
form = AgencyApplicationSubmissionForm(assignment)
|
|
|
|
context = {
|
|
"form": form,
|
|
"assignment": assignment,
|
|
"title": f"Submit Candidate for {assignment.job.title}",
|
|
"button_text": "Submit Candidate",
|
|
}
|
|
return render(request, "recruitment/agency_portal_submit_candidate.html", context)
|
|
|
|
|
|
def agency_portal_assignment_detail(request, slug):
|
|
"""View details of a specific assignment - routes to admin or agency template"""
|
|
assignment = get_object_or_404(
|
|
AgencyJobAssignment.objects.select_related("agency", "job"), slug=slug
|
|
)
|
|
|
|
# Check if user is authenticated and determine user type
|
|
if request.user.is_authenticated:
|
|
# Check if user has agency profile (agency user)
|
|
if hasattr(request.user, 'agency_profile') and request.user.agency_profile:
|
|
# Agency Portal User - Route to agency-specific template
|
|
return agency_assignment_detail_agency(request, slug, assignment.id)
|
|
else:
|
|
# Admin User - Route to admin template
|
|
return agency_assignment_detail_admin(request, slug)
|
|
else:
|
|
# Not authenticated - redirect to login
|
|
return redirect("portal_login")
|
|
|
|
|
|
@agency_user_required
|
|
def agency_assignment_detail_agency(request, slug, assignment_id):
|
|
"""Handle agency portal assignment detail view"""
|
|
# Get the assignment by slug and verify it belongs to same agency
|
|
assignment = get_object_or_404(
|
|
AgencyJobAssignment.objects.select_related("agency", "job"), slug=slug
|
|
)
|
|
|
|
# Verify this assignment belongs to the same agency as the logged-in session
|
|
current_assignment = get_object_or_404(
|
|
AgencyJobAssignment.objects.select_related("agency"), id=assignment_id
|
|
)
|
|
|
|
if assignment.agency.id != current_assignment.agency.id:
|
|
messages.error(
|
|
request, "Access denied: This assignment does not belong to your agency."
|
|
)
|
|
return redirect("agency_portal_dashboard")
|
|
|
|
# Get candidates submitted by this agency for this job
|
|
candidates = Application.objects.filter(
|
|
hiring_agency=assignment.agency, job=assignment.job
|
|
).order_by("-created_at")
|
|
|
|
# Get messages for this assignment
|
|
messages = []
|
|
|
|
# Mark messages as read
|
|
# No messages to mark as read
|
|
|
|
# Pagination for candidates
|
|
paginator = Paginator(candidates, 20) # Show 20 candidates per page
|
|
page_number = request.GET.get("page")
|
|
page_obj = paginator.get_page(page_number)
|
|
|
|
# Pagination for messages
|
|
message_paginator = Paginator(messages, 15) # Show 15 messages per page
|
|
message_page_number = request.GET.get("message_page")
|
|
message_page_obj = message_paginator.get_page(message_page_number)
|
|
|
|
# Calculate progress ring offset for circular progress indicator
|
|
total_candidates = candidates.count()
|
|
max_candidates = assignment.max_candidates
|
|
circumference = 326.73 # 2 * π * r where r=52
|
|
|
|
if max_candidates > 0:
|
|
progress_percentage = total_candidates / max_candidates
|
|
stroke_dashoffset = circumference - (circumference * progress_percentage)
|
|
else:
|
|
stroke_dashoffset = circumference
|
|
|
|
context = {
|
|
"assignment": assignment,
|
|
"page_obj": page_obj,
|
|
"message_page_obj": message_page_obj,
|
|
"total_candidates": total_candidates,
|
|
"stroke_dashoffset": stroke_dashoffset,
|
|
}
|
|
return render(request, "recruitment/agency_portal_assignment_detail.html", context)
|
|
|
|
|
|
@staff_user_required
|
|
def agency_assignment_detail_admin(request, slug):
|
|
"""Handle admin assignment detail view"""
|
|
assignment = get_object_or_404(
|
|
AgencyJobAssignment.objects.select_related("agency", "job"), slug=slug
|
|
)
|
|
|
|
# Get candidates submitted by this agency for this job
|
|
candidates = Application.objects.filter(
|
|
hiring_agency=assignment.agency, job=assignment.job
|
|
).order_by("-created_at")
|
|
|
|
# Get access link if exists
|
|
access_link = getattr(assignment, "access_link", None)
|
|
|
|
# Get messages for this assignment
|
|
messages = []
|
|
|
|
context = {
|
|
"assignment": assignment,
|
|
"candidates": candidates,
|
|
"access_link": access_link,
|
|
"total_candidates": candidates.count(),
|
|
}
|
|
return render(request, "recruitment/agency_assignment_detail.html", context)
|
|
|
|
|
|
@agency_user_required
|
|
def agency_portal_edit_candidate(request, candidate_id):
|
|
"""Edit a candidate for agency portal"""
|
|
assignment_id = request.session.get("agency_assignment_id")
|
|
if not assignment_id:
|
|
return redirect("agency_portal_login")
|
|
|
|
# Get current assignment to determine agency
|
|
current_assignment = get_object_or_404(
|
|
AgencyJobAssignment.objects.select_related("agency"), id=assignment_id
|
|
)
|
|
|
|
agency = current_assignment.agency
|
|
|
|
# Get candidate and verify it belongs to this agency
|
|
candidate = get_object_or_404(Application, id=candidate_id, hiring_agency=agency)
|
|
|
|
if request.method == "POST":
|
|
# Handle form submission
|
|
candidate.first_name = request.POST.get("first_name", candidate.first_name)
|
|
candidate.last_name = request.POST.get("last_name", candidate.last_name)
|
|
candidate.email = request.POST.get("email", candidate.email)
|
|
candidate.phone = request.POST.get("phone", candidate.phone)
|
|
candidate.address = request.POST.get("address", candidate.address)
|
|
|
|
# Handle resume upload if provided
|
|
if "resume" in request.FILES:
|
|
candidate.resume = request.FILES["resume"]
|
|
|
|
try:
|
|
candidate.save()
|
|
messages.success(
|
|
request, f"Candidate {candidate.name} updated successfully!"
|
|
)
|
|
return redirect(
|
|
"agency_assignment_detail",
|
|
slug=candidate.job.agencyjobassignment_set.first().slug,
|
|
)
|
|
except Exception as e:
|
|
messages.error(request, f"Error updating candidate: {e}")
|
|
|
|
# For GET requests or POST errors, return JSON response for AJAX
|
|
if request.headers.get("X-Requested-With") == "XMLHttpRequest":
|
|
return JsonResponse(
|
|
{
|
|
"success": True,
|
|
"candidate": {
|
|
"id": candidate.id,
|
|
"first_name": candidate.first_name,
|
|
"last_name": candidate.last_name,
|
|
"email": candidate.email,
|
|
"phone": candidate.phone,
|
|
"address": candidate.address,
|
|
},
|
|
}
|
|
)
|
|
|
|
# Fallback for non-AJAX requests
|
|
return redirect("agency_portal_dashboard")
|
|
|
|
|
|
@agency_user_required
|
|
def agency_portal_delete_candidate(request, candidate_id):
|
|
"""Delete a candidate for agency portal"""
|
|
assignment_id = request.session.get("agency_assignment_id")
|
|
if not assignment_id:
|
|
return redirect("agency_portal_login")
|
|
|
|
# Get current assignment to determine agency
|
|
current_assignment = get_object_or_404(
|
|
AgencyJobAssignment.objects.select_related("agency"), id=assignment_id
|
|
)
|
|
|
|
agency = current_assignment.agency
|
|
|
|
# Get candidate and verify it belongs to this agency
|
|
candidate = get_object_or_404(Application, id=candidate_id, hiring_agency=agency)
|
|
|
|
if request.method == "POST":
|
|
try:
|
|
candidate_name = candidate.name
|
|
candidate.delete()
|
|
|
|
current_assignment.candidates_submitted -= 1
|
|
current_assignment.status = current_assignment.AssignmentStatus.ACTIVE
|
|
current_assignment.save(update_fields=["candidates_submitted", "status"])
|
|
|
|
messages.success(
|
|
request, f"Candidate {candidate_name} removed successfully!"
|
|
)
|
|
return JsonResponse({"success": True})
|
|
except Exception as e:
|
|
return JsonResponse({"success": False, "error": str(e)})
|
|
|
|
# For GET requests, return error
|
|
return JsonResponse({"success": False, "error": "Method not allowed"})
|
|
|
|
|
|
# Message Views
|
|
|
|
def message_list(request):
|
|
"""List all messages for the current user"""
|
|
# Get filter parameters
|
|
status_filter = request.GET.get("status", "")
|
|
message_type_filter = request.GET.get("type", "")
|
|
search_query = request.GET.get("q", "")
|
|
|
|
# Base queryset - get messages where user is either sender or recipient
|
|
message_list = (
|
|
Message.objects.filter(Q(sender=request.user) | Q(recipient=request.user))
|
|
.select_related("sender", "recipient", "job")
|
|
.order_by("-created_at")
|
|
)
|
|
|
|
# Apply filters
|
|
if status_filter:
|
|
if status_filter == "read":
|
|
message_list = message_list.filter(is_read=True)
|
|
elif status_filter == "unread":
|
|
message_list = message_list.filter(is_read=False)
|
|
|
|
if message_type_filter:
|
|
message_list = message_list.filter(message_type=message_type_filter)
|
|
|
|
if search_query:
|
|
message_list = message_list.filter(
|
|
Q(subject__icontains=search_query) | Q(content__icontains=search_query)
|
|
)
|
|
|
|
# Pagination
|
|
paginator = Paginator(message_list, 20) # Show 20 messages per page
|
|
page_number = request.GET.get("page")
|
|
page_obj = paginator.get_page(page_number)
|
|
|
|
# Statistics
|
|
total_messages = message_list.count()
|
|
unread_messages = message_list.filter(is_read=False).count()
|
|
|
|
context = {
|
|
"page_obj": page_obj,
|
|
"total_messages": total_messages,
|
|
"unread_messages": unread_messages,
|
|
"status_filter": status_filter,
|
|
"type_filter": message_type_filter,
|
|
"search_query": search_query,
|
|
}
|
|
if request.user.user_type != "staff":
|
|
return render(request, "messages/candidate_message_list.html", context)
|
|
return render(request, "messages/message_list.html", context)
|
|
|
|
|
|
@login_required
|
|
def message_detail(request, message_id):
|
|
"""View details of a specific message"""
|
|
message = get_object_or_404(
|
|
Message.objects.select_related("sender", "recipient", "job"), id=message_id
|
|
)
|
|
|
|
# Check if user has permission to view this message
|
|
if message.sender != request.user and message.recipient != request.user:
|
|
messages.error(request, "You don't have permission to view this message.")
|
|
return redirect("message_list")
|
|
|
|
# Mark as read if it was unread and user is the recipient
|
|
if not message.is_read and message.recipient == request.user:
|
|
message.is_read = True
|
|
message.read_at = timezone.now()
|
|
message.save(update_fields=["is_read", "read_at"])
|
|
|
|
context = {
|
|
"message": message,
|
|
}
|
|
if request.user.user_type != "staff":
|
|
return render(request, "messages/candidate_message_detail.html", context)
|
|
return render(request, "messages/message_detail.html", context)
|
|
|
|
|
|
@login_required
|
|
def message_create(request):
|
|
"""Create a new message"""
|
|
from .email_service import EmailService
|
|
if request.method == "POST":
|
|
form = MessageForm(request.user, request.POST)
|
|
|
|
if form.is_valid():
|
|
message = form.save(commit=False)
|
|
message.sender = request.user
|
|
message.save()
|
|
# Send email if message_type is 'email' and recipient has email
|
|
|
|
if message.recipient and message.recipient.email:
|
|
|
|
try:
|
|
|
|
|
|
email_result = async_task('recruitment.tasks._task_send_individual_email',
|
|
subject=message.subject,
|
|
body_message=message.content,
|
|
recipient=message.recipient.email,
|
|
attachments=None,
|
|
sender=False,
|
|
job=False
|
|
)
|
|
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)}")
|
|
else:
|
|
|
|
messages.success(request, "Message sent successfully!")
|
|
|
|
|
|
return redirect("message_list")
|
|
else:
|
|
|
|
messages.error(request, "Please correct the errors below.")
|
|
else:
|
|
|
|
form = MessageForm(request.user)
|
|
|
|
context = {
|
|
"form": form,
|
|
}
|
|
if request.user.user_type != "staff":
|
|
return render(request, "messages/candidate_message_form.html", context)
|
|
return render(request, "messages/message_form.html", context)
|
|
|
|
|
|
@login_required
|
|
def message_reply(request, message_id):
|
|
"""Reply to a message"""
|
|
parent_message = get_object_or_404(
|
|
Message.objects.select_related("sender", "recipient", "job"), id=message_id
|
|
)
|
|
|
|
# Check if user has permission to reply to this message
|
|
if (
|
|
parent_message.recipient != request.user
|
|
and parent_message.sender != request.user
|
|
):
|
|
messages.error(request, "You don't have permission to reply to this message.")
|
|
return redirect("message_list")
|
|
|
|
if request.method == "POST":
|
|
form = MessageForm(request.user, request.POST)
|
|
if form.is_valid():
|
|
message = form.save(commit=False)
|
|
message.sender = request.user
|
|
message.parent_message = parent_message
|
|
# Set recipient as the original sender
|
|
message.recipient = parent_message.sender
|
|
message.save()
|
|
|
|
# Send email if message_type is 'email' and recipient has email
|
|
if message.recipient and message.recipient.email:
|
|
try:
|
|
email_result = async_task('recruitment.tasks._task_send_individual_email',
|
|
subject=message.subject,
|
|
body_message=message.content,
|
|
recipient=message.recipient.email,
|
|
attachments=None,
|
|
sender=False,
|
|
job=False
|
|
)
|
|
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"Reply saved but email sending failed: {str(e)}")
|
|
else:
|
|
messages.success(request, "Reply sent successfully!")
|
|
|
|
return redirect("message_detail", message_id=parent_message.id)
|
|
else:
|
|
messages.error(request, "Please correct the errors below.")
|
|
else:
|
|
# Pre-fill form with reply context
|
|
form = MessageForm(request.user)
|
|
form.initial["subject"] = f"Re: {parent_message.subject}"
|
|
form.initial["recipient"] = parent_message.sender
|
|
if parent_message.job:
|
|
form.initial["job"] = parent_message.job
|
|
form.initial["message_type"] = Message.MessageType.JOB_RELATED
|
|
|
|
context = {
|
|
"form": form,
|
|
"parent_message": parent_message,
|
|
}
|
|
if request.user.user_type != "staff":
|
|
return render(request, "messages/candidate_message_form.html", context)
|
|
return render(request, "messages/message_form.html", context)
|
|
|
|
|
|
@login_required
|
|
def message_mark_read(request, message_id):
|
|
"""Mark a message as read"""
|
|
message = get_object_or_404(
|
|
Message.objects.select_related("sender", "recipient"), id=message_id
|
|
)
|
|
|
|
# Check if user has permission to mark this message as read
|
|
if message.recipient != request.user:
|
|
messages.error(request, "You can only mark messages you received as read.")
|
|
return redirect("message_list")
|
|
|
|
# Mark as read
|
|
message.is_read = True
|
|
message.read_at = timezone.now()
|
|
message.save(update_fields=["is_read", "read_at"])
|
|
|
|
messages.success(request, "Message marked as read.")
|
|
|
|
# Handle HTMX requests
|
|
if "HX-Request" in request.headers:
|
|
return HttpResponse(status=200) # HTMX success response
|
|
|
|
return redirect("message_list")
|
|
|
|
|
|
@login_required
|
|
def message_mark_unread(request, message_id):
|
|
"""Mark a message as unread"""
|
|
message = get_object_or_404(
|
|
Message.objects.select_related("sender", "recipient"), id=message_id
|
|
)
|
|
|
|
# Check if user has permission to mark this message as unread
|
|
if message.recipient != request.user:
|
|
messages.error(request, "You can only mark messages you received as unread.")
|
|
return redirect("message_list")
|
|
|
|
# Mark as unread
|
|
message.is_read = False
|
|
message.read_at = None
|
|
message.save(update_fields=["is_read", "read_at"])
|
|
|
|
messages.success(request, "Message marked as unread.")
|
|
|
|
# Handle HTMX requests
|
|
if "HX-Request" in request.headers:
|
|
return HttpResponse(status=200) # HTMX success response
|
|
|
|
return redirect("message_list")
|
|
|
|
|
|
@login_required
|
|
def message_delete(request, message_id):
|
|
"""Delete a message"""
|
|
message = get_object_or_404(
|
|
Message.objects.select_related("sender", "recipient"), id=message_id
|
|
)
|
|
|
|
# Check if user has permission to delete this message
|
|
if message.sender != request.user and message.recipient != request.user:
|
|
messages.error(request, "You don't have permission to delete this message.")
|
|
return redirect("message_list")
|
|
|
|
if request.method == "POST":
|
|
message.delete()
|
|
messages.success(request, "Message deleted successfully.")
|
|
|
|
# Handle HTMX requests
|
|
if "HX-Request" in request.headers:
|
|
return HttpResponse(status=200) # HTMX success response
|
|
|
|
return redirect("message_list")
|
|
|
|
# For GET requests, show confirmation page
|
|
context = {
|
|
"message": message,
|
|
"title": "Delete Message",
|
|
"message": f"Are you sure you want to delete this message from {message.sender.get_full_name() or message.sender.username}?",
|
|
"cancel_url": reverse("message_detail", kwargs={"message_id": message_id}),
|
|
}
|
|
return render(request, "messages/message_confirm_delete.html", context)
|
|
|
|
|
|
@login_required
|
|
def api_unread_count(request):
|
|
"""API endpoint to get unread message count"""
|
|
unread_count = Message.objects.filter(recipient=request.user, is_read=False).count()
|
|
|
|
return JsonResponse({"unread_count": unread_count})
|
|
|
|
|
|
# Document Views
|
|
@login_required
|
|
def document_upload(request, slug):
|
|
"""Upload a document for an application or person"""
|
|
# Handle dynamic application_id from form
|
|
if request.method == "POST":
|
|
actual_application_id = request.POST.get('application_id', slug)
|
|
upload_target = request.POST.get('upload_target', 'application') # 'application' or 'person'
|
|
else:
|
|
actual_application_id = slug
|
|
upload_target = 'application'
|
|
|
|
# Handle case where application_id is 0 (placeholder)
|
|
if actual_application_id == '0':
|
|
return JsonResponse({"success": False, "error": "Please select an application first"})
|
|
|
|
if upload_target == 'person':
|
|
# Handle Person document upload
|
|
try:
|
|
person = get_object_or_404(Person, id=actual_application_id)
|
|
# Check if user owns this person (for candidate portal)
|
|
if request.user.user_type == "candidate":
|
|
candidate = request.user.person_profile
|
|
if person != candidate:
|
|
messages.error(request, "You can only upload documents to your own profile.")
|
|
return JsonResponse({"success": False, "error": "Permission denied"})
|
|
except (ValueError, Person.DoesNotExist):
|
|
return JsonResponse({"success": False, "error": "Invalid person ID"})
|
|
else:
|
|
# Existing Application logic (unchanged)
|
|
try:
|
|
application = get_object_or_404(Application, slug=actual_application_id)
|
|
except (ValueError, Application.DoesNotExist):
|
|
return JsonResponse({"success": False, "error": "Invalid application ID"})
|
|
|
|
# Check if user owns this application (for candidate portal)
|
|
if request.user.user_type == "candidate":
|
|
try:
|
|
candidate = request.user.person_profile
|
|
if application.person != candidate:
|
|
messages.error(request, "You can only upload documents to your own applications.")
|
|
return JsonResponse({"success": False, "error": "Permission denied"})
|
|
except:
|
|
messages.error(request, "No candidate profile found.")
|
|
return JsonResponse({"success": False, "error": "Permission denied"})
|
|
|
|
if request.method == "POST":
|
|
if request.FILES.get("file"):
|
|
if upload_target == 'person':
|
|
# Create document for Person
|
|
document = Document.objects.create(
|
|
content_object=person, # Use Generic Foreign Key to link to Person
|
|
file=request.FILES["file"],
|
|
document_type=request.POST.get("document_type", "other"),
|
|
description=request.POST.get("description", ""),
|
|
uploaded_by=request.user,
|
|
)
|
|
messages.success(
|
|
request,
|
|
f'Document "{document.get_document_type_display()}" uploaded successfully!',
|
|
)
|
|
|
|
# Handle AJAX requests
|
|
if request.headers.get("X-Requested-With") == "XMLHttpRequest":
|
|
return JsonResponse({
|
|
"success": True,
|
|
"message": "Document uploaded successfully!",
|
|
"document": {
|
|
"id": document.id,
|
|
"document_type": document.get_document_type_display(),
|
|
"description": document.description,
|
|
"created_at": document.created_at.strftime("%Y-%m-%d %H:%M"),
|
|
"file_name": document.file.name if document.file else "",
|
|
"file_size": f"{document.file.size / 1024:.1f} KB" if document.file else "0 KB"
|
|
}
|
|
})
|
|
|
|
return redirect("candidate_portal_dashboard")
|
|
else:
|
|
# Create document for Application (existing logic)
|
|
document = Document.objects.create(
|
|
content_object=application, # Use Generic Foreign Key to link to Application
|
|
file=request.FILES["file"],
|
|
document_type=request.POST.get("document_type", "other"),
|
|
description=request.POST.get("description", ""),
|
|
uploaded_by=request.user,
|
|
)
|
|
messages.success(
|
|
request,
|
|
f'Document "{document.get_document_type_display()}" uploaded successfully!',
|
|
)
|
|
|
|
# Handle AJAX requests
|
|
if request.headers.get("X-Requested-With") == "XMLHttpRequest":
|
|
return JsonResponse({
|
|
"success": True,
|
|
"message": "Document uploaded successfully!",
|
|
"document": {
|
|
"id": document.id,
|
|
"document_type": document.get_document_type_display(),
|
|
"description": document.description,
|
|
"created_at": document.created_at.strftime("%Y-%m-%d %H:%M"),
|
|
"file_name": document.file.name if document.file else "",
|
|
"file_size": f"{document.file.size / 1024:.1f} KB" if document.file else "0 KB"
|
|
}
|
|
})
|
|
if upload_target == 'person':
|
|
return redirect("candidate_portal_dashboard")
|
|
else:
|
|
return redirect("candidate_application_detail", application_slug=application.slug)
|
|
|
|
# Handle GET request for AJAX
|
|
if request.headers.get("X-Requested-With") == "XMLHttpRequest":
|
|
return JsonResponse({"success": False, "error": "Method not allowed"})
|
|
|
|
return redirect("candidate_detail", slug=application.job.slug)
|
|
|
|
@login_required
|
|
def document_delete(request, document_id):
|
|
"""Delete a document"""
|
|
document = get_object_or_404(Document, id=document_id)
|
|
|
|
# Check permission - document is now linked to Application or Person via Generic Foreign Key
|
|
if hasattr(document.content_object, "job"):
|
|
# Application document
|
|
if (
|
|
document.content_object.job.assigned_to != request.user
|
|
and not request.user.is_superuser
|
|
):
|
|
messages.error(
|
|
request, "You don't have permission to delete this document."
|
|
)
|
|
return JsonResponse({"success": False, "error": "Permission denied"})
|
|
job_slug = document.content_object.job.slug
|
|
redirect_url = "candidate_portal_dashboard" if request.user.user_type == "candidate" else "job_detail"
|
|
elif hasattr(document.content_object, "person"):
|
|
# Person document
|
|
if request.user.user_type == "candidate":
|
|
candidate = request.user.person_profile
|
|
if document.content_object != candidate:
|
|
messages.error(
|
|
request, "You can only delete your own documents."
|
|
)
|
|
return JsonResponse({"success": False, "error": "Permission denied"})
|
|
redirect_url = "candidate_portal_dashboard"
|
|
else:
|
|
# Handle other content object types
|
|
messages.error(request, "You don't have permission to delete this document.")
|
|
return JsonResponse({"success": False, "error": "Permission denied"})
|
|
|
|
if request.method == "POST":
|
|
file_name = document.file.name if document.file else "Unknown"
|
|
document.delete()
|
|
messages.success(request, f'Document "{file_name}" deleted successfully!')
|
|
|
|
# Handle AJAX requests
|
|
if request.headers.get("X-Requested-With") == "XMLHttpRequest":
|
|
return JsonResponse(
|
|
{"success": True, "message": "Document deleted successfully!"}
|
|
)
|
|
else:
|
|
return redirect("candidate_detail", slug=job_slug)
|
|
|
|
return JsonResponse({"success": False, "error": "Method not allowed"})
|
|
|
|
|
|
@login_required
|
|
def document_download(request, document_id):
|
|
"""Download a document"""
|
|
document = get_object_or_404(Document, id=document_id)
|
|
|
|
# Check permission - document is now linked to Application or Person via Generic Foreign Key
|
|
if hasattr(document.content_object, "job"):
|
|
if (
|
|
document.content_object.job.assigned_to != request.user
|
|
and not request.user.is_superuser
|
|
):
|
|
messages.error(
|
|
request, "You don't have permission to download this document."
|
|
)
|
|
return JsonResponse({"success": False, "error": "Permission denied"})
|
|
job_slug = document.content_object.job.slug
|
|
redirect_url = "candidate_detail" if request.user.user_type == "candidate" else "job_detail"
|
|
elif hasattr(document.content_object, "person"):
|
|
# Person document
|
|
if request.user.user_type == "candidate":
|
|
candidate = request.user.person_profile
|
|
if document.content_object != candidate:
|
|
messages.error(
|
|
request, "You can only download your own documents."
|
|
)
|
|
return JsonResponse({"success": False, "error": "Permission denied"})
|
|
redirect_url = "candidate_portal_dashboard"
|
|
else:
|
|
# Handle other content object types
|
|
messages.error(request, "You don't have permission to download this document.")
|
|
return JsonResponse({"success": False, "error": "Permission denied"})
|
|
|
|
if document.file:
|
|
response = HttpResponse(
|
|
document.file.read(), content_type="application/octet-stream"
|
|
)
|
|
response["Content-Disposition"] = f'attachment; filename="{document.file.name}"'
|
|
return response
|
|
|
|
return JsonResponse({"success": False, "error": "File not found"})
|
|
|
|
if document.file:
|
|
response = HttpResponse(
|
|
document.file.read(), content_type="application/octet-stream"
|
|
)
|
|
response["Content-Disposition"] = f'attachment; filename="{document.file.name}"'
|
|
return response
|
|
|
|
return JsonResponse({"success": False, "error": "File not found"})
|
|
|
|
|
|
@login_required
|
|
def portal_logout(request):
|
|
"""Logout from portal"""
|
|
logout(request)
|
|
|
|
messages.success(request, "You have been logged out.")
|
|
return redirect("portal_login")
|
|
|
|
|
|
@login_required
|
|
def agency_access_link_deactivate(request, slug):
|
|
"""Deactivate an agency access link"""
|
|
access_link = get_object_or_404(
|
|
AgencyAccessLink.objects.select_related(
|
|
"assignment__agency", "assignment__job"
|
|
),
|
|
slug=slug,
|
|
)
|
|
|
|
if request.method == "POST":
|
|
access_link.is_active = False
|
|
access_link.save(update_fields=["is_active"])
|
|
|
|
messages.success(
|
|
request,
|
|
f"Access link for {access_link.assignment.agency.name} - {access_link.assignment.job.title} has been deactivated.",
|
|
)
|
|
|
|
# Handle HTMX requests
|
|
if "HX-Request" in request.headers:
|
|
return HttpResponse(status=200) # HTMX success response
|
|
|
|
return redirect("agency_assignment_detail", slug=access_link.assignment.slug)
|
|
|
|
# For GET requests, show confirmation page
|
|
context = {
|
|
"access_link": access_link,
|
|
"title": "Deactivate Access Link",
|
|
"message": f"Are you sure you want to deactivate the access link for {access_link.assignment.agency.name}?",
|
|
"cancel_url": reverse(
|
|
"agency_assignment_detail", kwargs={"slug": access_link.assignment.slug}
|
|
),
|
|
}
|
|
return render(request, "recruitment/agency_access_link_confirm.html", context)
|
|
|
|
|
|
@login_required
|
|
def agency_access_link_reactivate(request, slug):
|
|
"""Reactivate an agency access link"""
|
|
access_link = get_object_or_404(
|
|
AgencyAccessLink.objects.select_related(
|
|
"assignment__agency", "assignment__job"
|
|
),
|
|
slug=slug,
|
|
)
|
|
|
|
if request.method == "POST":
|
|
access_link.is_active = True
|
|
access_link.save(update_fields=["is_active"])
|
|
|
|
messages.success(
|
|
request,
|
|
f"Access link for {access_link.assignment.agency.name} - {access_link.assignment.job.title} has been reactivated.",
|
|
)
|
|
|
|
# Handle HTMX requests
|
|
if "HX-Request" in request.headers:
|
|
return HttpResponse(status=200) # HTMX success response
|
|
|
|
return redirect("agency_assignment_detail", slug=access_link.assignment.slug)
|
|
|
|
# For GET requests, show confirmation page
|
|
context = {
|
|
"access_link": access_link,
|
|
"title": "Reactivate Access Link",
|
|
"message": f"Are you sure you want to reactivate the access link for {access_link.assignment.agency.name}?",
|
|
"cancel_url": reverse(
|
|
"agency_assignment_detail", kwargs={"slug": access_link.assignment.slug}
|
|
),
|
|
}
|
|
return render(request, "recruitment/agency_access_link_confirm.html", context)
|
|
|
|
|
|
@agency_user_required
|
|
def api_candidate_detail(request, candidate_id):
|
|
"""API endpoint to get candidate details for agency portal"""
|
|
try:
|
|
# Get candidate from session-based agency access
|
|
assignment_id = request.session.get("agency_assignment_id")
|
|
if not assignment_id:
|
|
return JsonResponse({"success": False, "error": "Access denied"})
|
|
|
|
# Get current assignment to determine agency
|
|
current_assignment = get_object_or_404(
|
|
AgencyJobAssignment.objects.select_related("agency"), id=assignment_id
|
|
)
|
|
|
|
agency = current_assignment.agency
|
|
|
|
# Get candidate and verify it belongs to this agency
|
|
candidate = get_object_or_404(
|
|
Application, id=candidate_id, hiring_agency=agency
|
|
)
|
|
|
|
# Return candidate data
|
|
response_data = {
|
|
"success": True,
|
|
"id": candidate.id,
|
|
"first_name": candidate.first_name,
|
|
"last_name": candidate.last_name,
|
|
"email": candidate.email,
|
|
"phone": candidate.phone,
|
|
"address": candidate.address,
|
|
}
|
|
|
|
return JsonResponse(response_data)
|
|
|
|
except Exception as e:
|
|
return JsonResponse({"success": False, "error": str(e)})
|
|
|
|
|
|
@staff_user_required
|
|
def compose_candidate_email(request, job_slug):
|
|
"""Compose email to participants about a candidate"""
|
|
from .email_service import send_bulk_email
|
|
|
|
job = get_object_or_404(JobPosting, slug=job_slug)
|
|
|
|
# # candidate = get_object_or_404(Application, slug=candidate_slug, job=job)
|
|
# if request.method == "POST":
|
|
# form = CandidateEmailForm(job, candidate, request.POST)
|
|
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')
|
|
candidates=Application.objects.filter(id__in=candidate_ids)
|
|
form = CandidateEmailForm(job, candidates, request.POST)
|
|
if form.is_valid():
|
|
print("form is valid ...")
|
|
# Get email addresses
|
|
email_addresses = form.get_email_addresses()
|
|
|
|
|
|
if not email_addresses:
|
|
messages.error(request, 'No email selected')
|
|
referer = request.META.get('HTTP_REFERER')
|
|
|
|
if referer:
|
|
# Redirect back to the referring page
|
|
return redirect(referer)
|
|
else:
|
|
|
|
return redirect('dashboard')
|
|
|
|
|
|
message = form.get_formatted_message()
|
|
subject = form.cleaned_data.get('subject')
|
|
|
|
# Send emails using email service (no attachments, synchronous to avoid pickle issues)
|
|
|
|
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
|
|
)
|
|
|
|
if email_result["success"]:
|
|
for candidate in candidates:
|
|
if hasattr(candidate, 'person') and candidate.person:
|
|
try:
|
|
Message.objects.create(
|
|
sender=request.user,
|
|
recipient=candidate.person.user,
|
|
subject=subject,
|
|
content=message,
|
|
job=job,
|
|
message_type='email',
|
|
is_email_sent=True,
|
|
email_address=candidate.person.email if candidate.person.email else candidate.email
|
|
)
|
|
|
|
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("candidate_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"
|
|
),
|
|
}
|
|
)
|
|
|
|
return render(
|
|
request,
|
|
"includes/email_compose_form.html",
|
|
{"form": form, "job": job, "candidate": candidates},
|
|
)
|
|
|
|
|
|
|
|
else:
|
|
# Form validation errors
|
|
messages.error(request, "Please correct the errors below.")
|
|
|
|
# For HTMX requests, return error response
|
|
if "HX-Request" in request.headers:
|
|
return JsonResponse(
|
|
{
|
|
"success": False,
|
|
"error": "Please correct the form errors and try again.",
|
|
}
|
|
)
|
|
|
|
return render(
|
|
request,
|
|
"includes/email_compose_form.html",
|
|
{"form": form, "job": job, "candidates": candidates},
|
|
)
|
|
|
|
else:
|
|
# GET request - show the form
|
|
form = CandidateEmailForm(job, candidates)
|
|
|
|
return render(
|
|
request,
|
|
"includes/email_compose_form.html",
|
|
# {"form": form, "job": job, "candidates": candidates},
|
|
{"form": form,"job":job},
|
|
)
|
|
|
|
|
|
|
|
# Source CRUD Views
|
|
@staff_user_required
|
|
def source_list(request):
|
|
"""List all sources with search and pagination"""
|
|
search_query = request.GET.get("q", "")
|
|
sources = Source.objects.all()
|
|
|
|
if search_query:
|
|
sources = sources.filter(
|
|
Q(name__icontains=search_query)
|
|
| Q(source_type__icontains=search_query)
|
|
| Q(description__icontains=search_query)
|
|
)
|
|
|
|
# Order by most recently created
|
|
sources = sources.order_by("-created_at")
|
|
|
|
# Pagination
|
|
paginator = Paginator(sources, 15) # Show 15 sources per page
|
|
page_number = request.GET.get("page")
|
|
page_obj = paginator.get_page(page_number)
|
|
|
|
context = {
|
|
"page_obj": page_obj,
|
|
"search_query": search_query,
|
|
"total_sources": sources.count(),
|
|
}
|
|
return render(request, "recruitment/source_list.html", context)
|
|
|
|
|
|
@staff_user_required
|
|
def source_create(request):
|
|
"""Create a new source"""
|
|
if request.method == "POST":
|
|
form = SourceForm(request.POST)
|
|
if form.is_valid():
|
|
source = form.save()
|
|
messages.success(request, f'Source "{source.name}" created successfully!')
|
|
return redirect("source_detail", slug=source.slug)
|
|
else:
|
|
messages.error(request, "Please correct the errors below.")
|
|
else:
|
|
form = SourceForm()
|
|
|
|
context = {
|
|
"form": form,
|
|
"title": "Create New Source",
|
|
"button_text": "Create Source",
|
|
}
|
|
return render(request, "recruitment/source_form.html", context)
|
|
|
|
|
|
@staff_user_required
|
|
def source_detail(request, slug):
|
|
"""View details of a specific source"""
|
|
source = get_object_or_404(Source, slug=slug)
|
|
|
|
# Get integration logs for this source
|
|
integration_logs = source.integration_logs.order_by("-created_at")[
|
|
:10
|
|
] # Show recent 10 logs
|
|
|
|
# Statistics
|
|
total_logs = source.integration_logs.count()
|
|
successful_logs = source.integration_logs.filter(method="POST").count()
|
|
failed_logs = source.integration_logs.filter(
|
|
method="POST", status_code__gte=400
|
|
).count()
|
|
|
|
context = {
|
|
"source": source,
|
|
"integration_logs": integration_logs,
|
|
"total_logs": total_logs,
|
|
"successful_logs": successful_logs,
|
|
"failed_logs": failed_logs,
|
|
}
|
|
return render(request, "recruitment/source_detail.html", context)
|
|
|
|
|
|
@staff_user_required
|
|
def source_update(request, slug):
|
|
"""Update an existing source"""
|
|
source = get_object_or_404(Source, slug=slug)
|
|
|
|
if request.method == "POST":
|
|
form = SourceForm(request.POST, instance=source)
|
|
if form.is_valid():
|
|
source = form.save()
|
|
messages.success(request, f'Source "{source.name}" updated successfully!')
|
|
return redirect("source_detail", slug=source.slug)
|
|
else:
|
|
messages.error(request, "Please correct the errors below.")
|
|
else:
|
|
form = SourceForm(instance=source)
|
|
|
|
context = {
|
|
"form": form,
|
|
"source": source,
|
|
"title": f"Edit Source: {source.name}",
|
|
"button_text": "Update Source",
|
|
}
|
|
return render(request, "recruitment/source_form.html", context)
|
|
|
|
|
|
@staff_user_required
|
|
def source_delete(request, slug):
|
|
"""Delete a source"""
|
|
source = get_object_or_404(Source, slug=slug)
|
|
|
|
if request.method == "POST":
|
|
source_name = source.name
|
|
source.delete()
|
|
messages.success(request, f'Source "{source_name}" deleted successfully!')
|
|
return redirect("source_list")
|
|
|
|
context = {
|
|
"source": source,
|
|
"title": "Delete Source",
|
|
"message": f'Are you sure you want to delete the source "{source.name}"?',
|
|
"cancel_url": reverse("source_detail", kwargs={"slug": source.slug}),
|
|
}
|
|
return render(request, "recruitment/source_confirm_delete.html", context)
|
|
|
|
|
|
@login_required
|
|
def source_generate_keys(request, slug):
|
|
"""Generate new API keys for a source"""
|
|
source = get_object_or_404(Source, slug=slug)
|
|
|
|
if request.method == "POST":
|
|
# Generate new API key and secret
|
|
from .forms import generate_api_key, generate_api_secret
|
|
|
|
source.api_key = generate_api_key()
|
|
source.api_secret = generate_api_secret()
|
|
source.save(update_fields=["api_key", "api_secret"])
|
|
|
|
messages.success(request, f'New API keys generated for "{source.name}"!')
|
|
return redirect("source_detail", slug=source.slug)
|
|
|
|
# For GET requests, show confirmation page
|
|
context = {
|
|
"source": source,
|
|
"title": "Generate New API Keys",
|
|
"message": f'Are you sure you want to generate new API keys for "{source.name}"? This will invalidate the existing keys.',
|
|
"cancel_url": reverse("source_detail", kwargs={"slug": source.slug}),
|
|
}
|
|
return render(request, "recruitment/source_confirm_generate_keys.html", context)
|
|
|
|
|
|
@login_required
|
|
def source_toggle_status(request, slug):
|
|
"""Toggle active status of a source"""
|
|
source = get_object_or_404(Source, slug=slug)
|
|
|
|
if request.method == "POST":
|
|
source.is_active = not source.is_active
|
|
source.save(update_fields=["is_active"])
|
|
|
|
status_text = "activated" if source.is_active else "deactivated"
|
|
messages.success(request, f'Source "{source.name}" has been {status_text}!')
|
|
|
|
# Handle HTMX requests
|
|
if "HX-Request" in request.headers:
|
|
return HttpResponse(status=200) # HTMX success response
|
|
|
|
return redirect("source_detail", slug=source.slug)
|
|
|
|
# For GET requests, return error
|
|
return JsonResponse({"success": False, "error": "Method not allowed"})
|
|
|
|
|
|
def candidate_signup(request, slug):
|
|
from .forms import CandidateSignupForm
|
|
|
|
form_template = get_object_or_404(FormTemplate, slug=slug)
|
|
job = form_template.job
|
|
|
|
if request.method == "POST":
|
|
form = CandidateSignupForm(request.POST)
|
|
if form.is_valid():
|
|
try:
|
|
first_name = form.cleaned_data["first_name"]
|
|
last_name = form.cleaned_data["last_name"]
|
|
email = form.cleaned_data["email"]
|
|
phone = form.cleaned_data["phone"]
|
|
gender = form.cleaned_data["gender"]
|
|
nationality = form.cleaned_data["nationality"]
|
|
address = form.cleaned_data["address"]
|
|
# gpa = form.cleaned_data["gpa"]
|
|
password = form.cleaned_data["password"]
|
|
|
|
user = User.objects.create_user(
|
|
username = email,email=email,first_name=first_name,last_name=last_name,phone=phone,user_type="candidate"
|
|
)
|
|
user.set_password(password)
|
|
user.save()
|
|
Person.objects.create(
|
|
first_name=first_name,
|
|
last_name=last_name,
|
|
email=email,
|
|
phone=phone,
|
|
gender=gender,
|
|
nationality=nationality,
|
|
# gpa=gpa,
|
|
address=address,
|
|
user = user
|
|
)
|
|
login(request, user,backend='django.contrib.auth.backends.ModelBackend')
|
|
|
|
return redirect("application_submit_form", template_slug=slug)
|
|
except Exception as e:
|
|
messages.error(request, f"Error creating application: {str(e)}")
|
|
return render(
|
|
request,
|
|
"recruitment/candidate_signup.html",
|
|
{"form": form, "job": job},
|
|
)
|
|
|
|
form = CandidateSignupForm()
|
|
return render(
|
|
request, "recruitment/candidate_signup.html", {"form": form, "job": job}
|
|
)
|
|
|
|
|
|
from .forms import InterviewParticpantsForm
|
|
|
|
|
|
# def create_interview_participants(request, slug):
|
|
# schedule_interview = get_object_or_404(ScheduledInterview, slug=slug)
|
|
# interview_slug = schedule_interview.zoom_meeting.slug
|
|
# if request.method == "POST":
|
|
# form = InterviewParticpantsForm(request.POST, instance=schedule_interview)
|
|
# if form.is_valid():
|
|
# # Save the main Candidate object, but don't commit to DB yet
|
|
# candidate = form.save(commit=False)
|
|
# candidate.save()
|
|
# # This is important for ManyToMany fields: save the many-to-many data
|
|
# form.save_m2m()
|
|
# return redirect(
|
|
# "meeting_details", slug=interview_slug
|
|
# ) # Redirect to a success page
|
|
# else:
|
|
# form = InterviewParticpantsForm(instance=schedule_interview)
|
|
|
|
# return render(
|
|
# request, "interviews/interview_participants_form.html", {"form": form}
|
|
# )
|
|
|
|
def create_interview_participants(request, slug):
|
|
"""
|
|
Manage participants for a ScheduledInterview.
|
|
Uses interview_pk because ScheduledInterview has no slug.
|
|
"""
|
|
schedule_interview = get_object_or_404(ScheduledInterview, slug=slug)
|
|
|
|
# Get the slug from the related InterviewLocation (the "meeting")
|
|
meeting_slug = schedule_interview.interview_location.slug # ✅ Correct
|
|
|
|
if request.method == "POST":
|
|
form = InterviewParticpantsForm(request.POST, instance=schedule_interview)
|
|
if form.is_valid():
|
|
form.save() # No need for commit=False — it's not a create, just update
|
|
messages.success(request, "Participants updated successfully.")
|
|
return redirect("meeting_details", slug=meeting_slug)
|
|
else:
|
|
form = InterviewParticpantsForm(instance=schedule_interview)
|
|
|
|
return render(
|
|
request,
|
|
"interviews/interview_participants_form.html",
|
|
{"form": form, "interview": schedule_interview}
|
|
)
|
|
|
|
|
|
from django.core.mail import send_mail
|
|
|
|
|
|
def send_interview_email(request, slug):
|
|
from .email_service import send_bulk_email
|
|
|
|
interview = get_object_or_404(ScheduledInterview, slug=slug)
|
|
|
|
# 2. Retrieve the required data for the form's constructor
|
|
candidate = interview.application
|
|
job = interview.job
|
|
meeting = interview.interview_location
|
|
participants = list(interview.participants.all()) + list(
|
|
interview.system_users.all()
|
|
)
|
|
external_participants = list(interview.participants.all())
|
|
system_participants = list(interview.system_users.all())
|
|
|
|
participant_emails = [p.email for p in participants if hasattr(p, "email")]
|
|
print(participant_emails)
|
|
total_recipients = 1 + len(participant_emails)
|
|
|
|
# --- POST REQUEST HANDLING ---
|
|
if request.method == "POST":
|
|
form = InterviewEmailForm(
|
|
request.POST,
|
|
candidate=candidate,
|
|
external_participants=external_participants,
|
|
system_participants=system_participants,
|
|
meeting=meeting,
|
|
job=job,
|
|
)
|
|
|
|
if form.is_valid():
|
|
# 4. Extract cleaned data
|
|
subject = form.cleaned_data["subject"]
|
|
msg_candidate = form.cleaned_data["message_for_candidate"]
|
|
msg_agency = form.cleaned_data["message_for_agency"]
|
|
msg_participants = form.cleaned_data["message_for_participants"]
|
|
|
|
# --- SEND EMAILS Candidate or agency---
|
|
if candidate.belong_to_an_agency:
|
|
email=candidate.hiring_agency.email
|
|
print(email)
|
|
send_mail(
|
|
subject,
|
|
msg_agency,
|
|
settings.DEFAULT_FROM_EMAIL,
|
|
[candidate.hiring_agency.email],
|
|
fail_silently=False,
|
|
)
|
|
else:
|
|
send_mail(
|
|
subject,
|
|
msg_candidate,
|
|
settings.DEFAULT_FROM_EMAIL,
|
|
[candidate.person.email],
|
|
fail_silently=False,
|
|
)
|
|
|
|
email_result = send_bulk_email(
|
|
subject=subject,
|
|
message=msg_participants,
|
|
recipient_list=participant_emails,
|
|
request=request,
|
|
attachments=None,
|
|
async_task_=True, # Changed to False to avoid pickle issues,
|
|
from_interview=True,
|
|
job=job
|
|
|
|
)
|
|
|
|
if email_result["success"]:
|
|
# Create Message records for each participant after successful email send
|
|
messages_created = 0
|
|
for participant in participants:
|
|
if hasattr(participant, 'user') and participant.user:
|
|
try:
|
|
Message.objects.create(
|
|
sender=request.user,
|
|
recipient=participant.user,
|
|
subject=subject,
|
|
content=msg_participants,
|
|
job=job,
|
|
message_type='email',
|
|
is_email_sent=True,
|
|
email_address=participant.email if hasattr(participant, 'email') else ''
|
|
)
|
|
messages_created += 1
|
|
except Exception as e:
|
|
# Log error but don't fail the entire process
|
|
print(f"Error creating message for {participant.email if hasattr(participant, 'email') else participant}: {e}")
|
|
|
|
messages.success(
|
|
request,
|
|
f"Email will be sent shortly to {total_recipients} recipient(s).",
|
|
)
|
|
|
|
return redirect("list_meetings")
|
|
else:
|
|
messages.error(
|
|
request,
|
|
f"Failed to send email: {email_result.get('message', 'Unknown error')}",
|
|
)
|
|
return redirect("list_meetings")
|
|
else:
|
|
|
|
error_msg = "Failed to send email. Please check the form for errors."
|
|
print(form.errors)
|
|
messages.error(request, error_msg)
|
|
return redirect("meeting_details", slug=meeting.slug)
|
|
return redirect("meeting_details", slug=meeting.slug)
|
|
|
|
|
|
def schedule_interview_location_form(request,slug):
|
|
schedule=get_object_or_404(InterviewSchedule,slug=slug)
|
|
if request.method=='POST':
|
|
form=InterviewScheduleLocationForm(request.POST,instance=schedule)
|
|
form.save()
|
|
return redirect('list_meetings')
|
|
else:
|
|
form=InterviewScheduleLocationForm(instance=schedule)
|
|
return render(request,'interviews/schedule_interview_location_form.html',{'form':form,'schedule':schedule})
|
|
|
|
|
|
class MeetingListView(ListView):
|
|
"""
|
|
A unified view to list both Remote and Onsite Scheduled Interviews.
|
|
"""
|
|
model = ScheduledInterview
|
|
template_name = "meetings/list_meetings.html"
|
|
context_object_name = "meetings"
|
|
paginate_by = 100
|
|
|
|
|
|
def get_queryset(self):
|
|
# Start with a base queryset, ensuring an InterviewLocation link exists.
|
|
queryset = super().get_queryset().filter(interview_location__isnull=False).select_related(
|
|
'interview_location',
|
|
'job',
|
|
'application__person',
|
|
'application',
|
|
).prefetch_related(
|
|
'interview_location__zoommeetingdetails',
|
|
'interview_location__onsitelocationdetails',
|
|
)
|
|
|
|
# Note: Printing the queryset here can consume memory for large sets.
|
|
|
|
# Get filters from GET request
|
|
search_query = self.request.GET.get("q")
|
|
status_filter = self.request.GET.get("status")
|
|
candidate_name_filter = self.request.GET.get("candidate_name")
|
|
type_filter = self.request.GET.get("type")
|
|
print(type_filter)
|
|
|
|
# 2. Type Filter: Filter based on the base InterviewLocation's type
|
|
if type_filter:
|
|
# Use .title() to handle case variations from URL (e.g., 'remote' -> 'Remote')
|
|
normalized_type = type_filter.title()
|
|
|
|
# Assuming InterviewLocation.LocationType is accessible/defined
|
|
if normalized_type in ['Remote', 'Onsite']:
|
|
queryset = queryset.filter(interview_location__location_type=normalized_type)
|
|
|
|
# 3. Search by Topic (stored on InterviewLocation)
|
|
if search_query:
|
|
queryset = queryset.filter(interview_location__topic__icontains=search_query)
|
|
|
|
# 4. Status Filter
|
|
if status_filter:
|
|
queryset = queryset.filter(status=status_filter)
|
|
|
|
# 5. Candidate Name Filter
|
|
if candidate_name_filter:
|
|
queryset = queryset.filter(
|
|
Q(application__person__first_name__icontains=candidate_name_filter) |
|
|
Q(application__person__last_name__icontains=candidate_name_filter)
|
|
)
|
|
|
|
return queryset.order_by("-interview_date", "-interview_time")
|
|
|
|
|
|
def get_context_data(self, **kwargs):
|
|
context = super().get_context_data(**kwargs)
|
|
|
|
# Pass filters back to the template for retention
|
|
context["search_query"] = self.request.GET.get("q", "")
|
|
context["status_filter"] = self.request.GET.get("status", "")
|
|
context["candidate_name_filter"] = self.request.GET.get("candidate_name", "")
|
|
context["type_filter"] = self.request.GET.get("type", "")
|
|
|
|
|
|
# CORRECTED: Pass the status choices from the model class for the filter dropdown
|
|
context["status_choices"] = self.model.InterviewStatus.choices
|
|
|
|
meetings_data = []
|
|
|
|
for interview in context.get(self.context_object_name, []):
|
|
location = interview.interview_location
|
|
details = None
|
|
|
|
if not location:
|
|
continue
|
|
|
|
# Determine and fetch the CONCRETE details object (prefetched)
|
|
if location.location_type == location.LocationType.REMOTE:
|
|
details = getattr(location, 'zoommeetingdetails', None)
|
|
elif location.location_type == location.LocationType.ONSITE:
|
|
details = getattr(location, 'onsitelocationdetails', None)
|
|
|
|
# Combine date and time for template display/sorting
|
|
start_datetime = None
|
|
if interview.interview_date and interview.interview_time:
|
|
start_datetime = datetime.combine(interview.interview_date, interview.interview_time)
|
|
|
|
# SUCCESS: Build the data dictionary
|
|
meetings_data.append({
|
|
'interview': interview,
|
|
'location': location,
|
|
'details': details,
|
|
'type': location.location_type,
|
|
'topic': location.topic,
|
|
'slug': interview.slug,
|
|
'start_time': start_datetime, # Combined datetime object
|
|
# Duration should ideally be on ScheduledInterview or fetched from details
|
|
'duration': getattr(details, 'duration', 'N/A'),
|
|
# Use details.join_url and fallback to None, if Remote
|
|
'join_url': getattr(details, 'join_url', None) if location.location_type == location.LocationType.REMOTE else None,
|
|
'meeting_id': getattr(details, 'meeting_id', None),
|
|
# Use the primary status from the ScheduledInterview record
|
|
'status': interview.status,
|
|
})
|
|
|
|
context["meetings_data"] = meetings_data
|
|
|
|
return context
|
|
|
|
|
|
# class MeetingListView(ListView):
|
|
# """
|
|
# A unified view to list both Remote and Onsite Scheduled Interviews.
|
|
# """
|
|
# model = InterviewLocation
|
|
# template_name = "meetings/list_meetings.html"
|
|
# context_object_name = "meetings"
|
|
|
|
|
|
|
|
# def get_queryset(self):
|
|
# # Start with a base queryset, ensuring an InterviewLocation link exists.
|
|
# queryset = super().get_queryset().prefetch_related(
|
|
# 'zoommeetingdetails',
|
|
# 'onsitelocationdetails',
|
|
# )
|
|
# print(queryset)
|
|
|
|
# return queryset
|
|
|
|
|
|
def reschedule_onsite_meeting(request, slug, candidate_id, meeting_id):
|
|
"""Handles the rescheduling of an Onsite Interview (updates OnsiteLocationDetails)."""
|
|
job = get_object_or_404(JobPosting, slug=slug)
|
|
candidate = get_object_or_404(Application, pk=candidate_id)
|
|
|
|
# Fetch the OnsiteLocationDetails instance, ensuring it belongs to this candidate.
|
|
# We use the reverse relationship: onsitelocationdetails -> interviewlocation -> scheduledinterview -> application
|
|
# The 'interviewlocation_ptr' is the foreign key field name if OnsiteLocationDetails is a proxy/multi-table inheritance model.
|
|
onsite_meeting = get_object_or_404(
|
|
OnsiteLocationDetails,
|
|
pk=meeting_id,
|
|
# Correct filter: Use the reverse link through the ScheduledInterview model.
|
|
# This assumes your ScheduledInterview model links back to a generic InterviewLocation base.
|
|
interviewlocation_ptr__scheduled_interview__application=candidate
|
|
)
|
|
|
|
if request.method == 'POST':
|
|
form = OnsiteReshuduleForm(request.POST, instance=onsite_meeting)
|
|
|
|
if form.is_valid():
|
|
instance = form.save(commit=False)
|
|
|
|
if instance.start_time < timezone.now():
|
|
messages.error(request, "Start time must be in the future for rescheduling.")
|
|
return render(request, "meetings/reschedule_onsite.html", {"form": form, "job": job, "candidate": candidate, "meeting": onsite_meeting})
|
|
|
|
# Update parent status
|
|
try:
|
|
# Retrieve the ScheduledInterview instance via the reverse relationship
|
|
scheduled_interview = ScheduledInterview.objects.get(
|
|
interview_location=instance.interviewlocation_ptr # Use the base model FK
|
|
)
|
|
scheduled_interview.status = ScheduledInterview.InterviewStatus.SCHEDULED
|
|
scheduled_interview.save()
|
|
except ScheduledInterview.DoesNotExist:
|
|
messages.warning(request, "Parent schedule record not found. Status not updated.")
|
|
|
|
instance.save()
|
|
messages.success(request, "Onsite meeting successfully rescheduled! ✅")
|
|
|
|
return redirect(reverse("candidate_interview_view", kwargs={'slug': job.slug}))
|
|
|
|
else:
|
|
form = OnsiteReshuduleForm(instance=onsite_meeting)
|
|
|
|
context = {
|
|
"form": form,
|
|
"job": job,
|
|
"candidate": candidate,
|
|
"meeting": onsite_meeting
|
|
}
|
|
return render(request, "meetings/reschedule_onsite_meeting.html", context)
|
|
|
|
|
|
# recruitment/views.py
|
|
|
|
@staff_user_required
|
|
def delete_onsite_meeting_for_candidate(request, slug, candidate_pk, meeting_id):
|
|
"""
|
|
Deletes a specific Onsite Location Details instance.
|
|
This does not require an external API call.
|
|
"""
|
|
job = get_object_or_404(JobPosting, slug=slug)
|
|
candidate = get_object_or_404(Application, pk=candidate_pk)
|
|
|
|
# Target the specific Onsite meeting details instance
|
|
meeting = get_object_or_404(OnsiteLocationDetails, pk=meeting_id)
|
|
|
|
if request.method == "POST":
|
|
# Delete the local Django object.
|
|
# This deletes the base InterviewLocation and updates the ScheduledInterview FK.
|
|
meeting.delete()
|
|
messages.success(request, f"Onsite meeting for {candidate.name} deleted successfully.")
|
|
|
|
return redirect(reverse("candidate_interview_view", kwargs={"slug": job.slug}))
|
|
|
|
context = {
|
|
"job": job,
|
|
"candidate": candidate,
|
|
"meeting": meeting,
|
|
"location_type": "Onsite",
|
|
"delete_url": reverse(
|
|
"delete_onsite_meeting_for_candidate", # Use the specific new URL name
|
|
kwargs={
|
|
"slug": job.slug,
|
|
"candidate_pk": candidate_pk,
|
|
"meeting_id": meeting_id,
|
|
},
|
|
),
|
|
}
|
|
return render(request, "meetings/delete_meeting_form.html", context)
|
|
|
|
|
|
|
|
def schedule_onsite_meeting_for_candidate(request, slug, candidate_pk):
|
|
"""
|
|
Handles scheduling a NEW Onsite Interview for a candidate using OnsiteScheduleForm.
|
|
"""
|
|
job = get_object_or_404(JobPosting, slug=slug)
|
|
candidate = get_object_or_404(Application, pk=candidate_pk)
|
|
|
|
action_url = reverse('schedule_onsite_meeting_for_candidate',
|
|
kwargs={'slug': job.slug, 'candidate_pk': candidate.pk})
|
|
|
|
if request.method == 'POST':
|
|
# Use the new form
|
|
form = OnsiteScheduleForm(request.POST)
|
|
if form.is_valid():
|
|
|
|
cleaned_data = form.cleaned_data
|
|
|
|
# 1. Create OnsiteLocationDetails
|
|
onsite_loc = OnsiteLocationDetails(
|
|
topic=cleaned_data['topic'],
|
|
physical_address=cleaned_data['physical_address'],
|
|
room_number=cleaned_data['room_number'],
|
|
start_time=cleaned_data['start_time'],
|
|
duration=cleaned_data['duration'],
|
|
status=OnsiteLocationDetails.Status.WAITING,
|
|
location_type=InterviewLocation.LocationType.ONSITE,
|
|
)
|
|
onsite_loc.save()
|
|
|
|
# 2. Extract Date and Time
|
|
interview_date = cleaned_data['start_time'].date()
|
|
interview_time = cleaned_data['start_time'].time()
|
|
|
|
# 3. Create ScheduledInterview linked to the new location
|
|
# Use cleaned_data['application'] and cleaned_data['job'] from the form
|
|
ScheduledInterview.objects.create(
|
|
application=cleaned_data['application'],
|
|
job=cleaned_data['job'],
|
|
interview_location=onsite_loc,
|
|
interview_date=interview_date,
|
|
interview_time=interview_time,
|
|
status=ScheduledInterview.InterviewStatus.SCHEDULED,
|
|
)
|
|
|
|
messages.success(request, "Onsite interview scheduled successfully. ✅")
|
|
return redirect(reverse("candidate_interview_view", kwargs={'slug': job.slug}))
|
|
|
|
else:
|
|
# GET Request: Initialize the hidden fields with the correct objects
|
|
initial_data = {
|
|
'application': candidate, # Pass the object itself for ModelChoiceField
|
|
'job': job, # Pass the object itself for ModelChoiceField
|
|
}
|
|
# Use the new form
|
|
form = OnsiteScheduleForm(initial=initial_data)
|
|
|
|
context = {
|
|
"form": form,
|
|
"job": job,
|
|
"candidate": candidate,
|
|
"action_url": action_url,
|
|
}
|
|
|
|
return render(request, "meetings/schedule_onsite_meeting_form.html", context)
|
|
|
|
|
|
|
|
from django.http import Http404
|
|
|
|
|
|
def meeting_details(request, slug):
|
|
# Fetch the meeting (InterviewLocation or subclass) by slug
|
|
meeting = get_object_or_404(
|
|
InterviewLocation.objects.select_related(
|
|
'scheduled_interview__application__person',
|
|
'scheduled_interview__job',
|
|
'zoommeetingdetails',
|
|
'onsitelocationdetails',
|
|
).prefetch_related(
|
|
'scheduled_interview__participants',
|
|
'scheduled_interview__system_users',
|
|
'scheduled_interview__notes',
|
|
),
|
|
slug=slug
|
|
)
|
|
|
|
try:
|
|
interview = meeting.scheduled_interview
|
|
except ScheduledInterview.DoesNotExist:
|
|
raise Http404("No interview is associated with this meeting.")
|
|
|
|
candidate = interview.application
|
|
job = interview.job
|
|
|
|
external_participants = interview.participants.all()
|
|
system_participants = interview.system_users.all()
|
|
total_participants = external_participants.count() + system_participants.count()
|
|
|
|
# Forms for modals
|
|
participant_form = InterviewParticpantsForm(instance=interview)
|
|
|
|
|
|
email_form = InterviewEmailForm(
|
|
candidate=candidate,
|
|
external_participants=external_participants, # QuerySet of Participants
|
|
system_participants=system_participants, # QuerySet of Users
|
|
meeting=meeting, # ← This is InterviewLocation (e.g., ZoomMeetingDetails)
|
|
job=job,
|
|
)
|
|
|
|
context = {
|
|
'meeting': meeting,
|
|
'interview': interview,
|
|
'candidate': candidate,
|
|
'job': job,
|
|
'external_participants': external_participants,
|
|
'system_participants': system_participants,
|
|
'total_participants': total_participants,
|
|
'form': participant_form,
|
|
'email_form': email_form,
|
|
}
|
|
|
|
return render(request, 'interviews/detail_interview.html', context)
|
|
|
|
|
|
@login_required
|
|
def send_candidate_invitation(request, slug):
|
|
"""Send invitation email to the candidate"""
|
|
meeting = get_object_or_404(InterviewLocation, slug=slug)
|
|
|
|
try:
|
|
interview = meeting.scheduled_interview
|
|
except ScheduledInterview.DoesNotExist:
|
|
raise Http404("No interview is associated with this meeting.")
|
|
|
|
candidate = interview.application
|
|
job = interview.job
|
|
|
|
if request.method == 'POST':
|
|
try:
|
|
from django.core.mail import send_mail
|
|
from django.conf import settings
|
|
|
|
# Simple email content
|
|
subject = f"Interview Invitation - {job.title}"
|
|
message = f"""
|
|
Dear {candidate.person.first_name} {candidate.person.last_name},
|
|
|
|
You are invited for an interview for the position of {job.title}.
|
|
|
|
Meeting Details:
|
|
- Date: {interview.interview_date}
|
|
- Time: {interview.interview_time}
|
|
- Duration: {meeting.duration or 60} minutes
|
|
"""
|
|
|
|
# Add join URL if it's a Zoom meeting
|
|
if hasattr(meeting, 'zoommeetingdetails') and meeting.zoommeetingdetails.join_url:
|
|
message += f"- Join URL: {meeting.zoommeetingdetails.join_url}\n"
|
|
|
|
# Add physical address if it's an onsite meeting
|
|
if hasattr(meeting, 'onsitelocationdetails') and meeting.onsitelocationdetails.physical_address:
|
|
message += f"- Location: {meeting.onsitelocationdetails.physical_address}\n"
|
|
if meeting.onsitelocationdetails.room_number:
|
|
message += f"- Room: {meeting.onsitelocationdetails.room_number}\n"
|
|
|
|
message += """
|
|
Please confirm your attendance.
|
|
|
|
Best regards,
|
|
KAAUH Recruitment Team
|
|
"""
|
|
|
|
# Send email
|
|
send_mail(
|
|
subject,
|
|
message,
|
|
settings.DEFAULT_FROM_EMAIL,
|
|
[candidate.person.email],
|
|
fail_silently=False,
|
|
)
|
|
|
|
messages.success(request, f"Invitation email sent to {candidate.person.email}")
|
|
|
|
except Exception as e:
|
|
messages.error(request, f"Failed to send invitation email: {str(e)}")
|
|
|
|
return redirect('meeting_details', slug=slug)
|
|
|
|
|
|
@login_required
|
|
def send_participants_invitation(request, slug):
|
|
"""Send invitation email to all participants"""
|
|
meeting = get_object_or_404(InterviewLocation, slug=slug)
|
|
|
|
try:
|
|
interview = meeting.scheduled_interview
|
|
except ScheduledInterview.DoesNotExist:
|
|
raise Http404("No interview is associated with this meeting.")
|
|
|
|
candidate = interview.application
|
|
job = interview.job
|
|
|
|
if request.method == 'POST':
|
|
try:
|
|
from django.core.mail import send_mail
|
|
from django.conf import settings
|
|
|
|
# Get all participants
|
|
participants = list(interview.participants.all())
|
|
system_users = list(interview.system_users.all())
|
|
all_participants = participants + system_users
|
|
|
|
if not all_participants:
|
|
messages.warning(request, "No participants found to send invitation to.")
|
|
return redirect('meeting_details', slug=slug)
|
|
|
|
# Simple email content
|
|
subject = f"Interview Invitation - {job.title} with {candidate.person.first_name} {candidate.person.last_name}"
|
|
message = f"""
|
|
Dear Team Member,
|
|
|
|
You are invited to participate in an interview session.
|
|
|
|
Interview Details:
|
|
- Candidate: {candidate.person.first_name} {candidate.person.last_name}
|
|
- Position: {job.title}
|
|
- Date: {interview.interview_date}
|
|
- Time: {interview.interview_time}
|
|
- Duration: {meeting.duration or 60} minutes
|
|
"""
|
|
|
|
# Add join URL if it's a Zoom meeting
|
|
if hasattr(meeting, 'zoommeetingdetails') and meeting.zoommeetingdetails.join_url:
|
|
message += f"- Join URL: {meeting.zoommeetingdetails.join_url}\n"
|
|
|
|
# Add physical address if it's an onsite meeting
|
|
if hasattr(meeting, 'onsitelocationdetails') and meeting.onsitelocationdetails.physical_address:
|
|
message += f"- Location: {meeting.onsitelocationdetails.physical_address}\n"
|
|
if meeting.onsitelocationdetails.room_number:
|
|
message += f"- Room: {meeting.onsitelocationdetails.room_number}\n"
|
|
|
|
message += """
|
|
Please confirm your availability.
|
|
|
|
Best regards,
|
|
KAAUH Recruitment Team
|
|
"""
|
|
|
|
# Get email addresses of all participants
|
|
recipient_emails = []
|
|
for participant in all_participants:
|
|
if hasattr(participant, 'email') and participant.email:
|
|
recipient_emails.append(participant.email)
|
|
|
|
if recipient_emails:
|
|
# Send email to all participants
|
|
send_mail(
|
|
subject,
|
|
message,
|
|
settings.DEFAULT_FROM_EMAIL,
|
|
recipient_emails,
|
|
fail_silently=False,
|
|
)
|
|
|
|
messages.success(request, f"Invitation emails sent to {len(recipient_emails)} participants")
|
|
else:
|
|
messages.warning(request, "No valid email addresses found for participants.")
|
|
|
|
except Exception as e:
|
|
messages.error(request, f"Failed to send invitation emails: {str(e)}")
|
|
|
|
return redirect('meeting_details', slug=slug)
|