def edit_employer_profile(request, id):
user = get_user_type(request)
if user['obj'] is not None:
if request.method == 'POST':
employer = Employer.objects.get(user_id=id)
form = EmployerForm(request.POST, request.FILES, instance=employer)
if form.is_valid():
form.save()
url = '{}/{}'.format('/my_admin/view_employer_profile', id)
return redirect(url)
else:
messages.warning(request, form.errors.as_text)
url = '{}/{}'.format('/my_admin/edit_employer_profile', id)
return redirect(url)
else:
employer = Employer.objects.get(user_id=id)
form = EmployerForm(instance=employer)
args = {
'employer_form': form,
'obj': employer,
'user_type': user['user_type']
}
return render(request, 'Employer/edit_employer_profile.html', args)
else:
messages.info(request, 'This employer user does not exist')
def get(self, request, *args, **kwargs):
user = get_user_type(request)
if kwargs:
pk = kwargs[
'pk'] # get a particular instance of the IT Support Form filled previously
help_desk_form = HelpDeskForm(instance=HelpDeskModel.objects.get(
id=pk))
help_desk_form.fields[
'subject'].disabled = True # the subject field cannot be edited once submitted
help_desk_form.fields[
'issue'].disabled = True # the issue field cannot be edited once submitted
else:
help_desk_form = HelpDeskForm(
) # get a new form if a previous one does not exist
try:
thread = HelpDeskModel.objects.get(id=pk)
except:
thread = []
args = {
'help_desk_form': help_desk_form,
'thread': thread,
'user_type': user['user_type'],
'obj': user['obj']
}
return render(request, self.template_name, args)
def get(self, request, *args, **kwargs):
c = HelpDeskModel.objects.all().order_by("-completed_date")
user = get_user_type(request)
args = {'reqs': c, 'user_type': user['user_type'], 'obj': user['obj']}
print(c)
return render(request, 'HelpDesk/Admin_List_of_Requests.html', args)
def view_students(request):
user = get_user_type(request)
if request.method == 'POST':
alumni_status = request.POST.get("alumni_status")
skills = request.POST.get("skills")
min_graduation_date = request.POST.get('min_graduation_date')
max_graduation_date = request.POST.get('max_graduation_date')
if alumni_status:
if alumni_status == "Alumni":
alumni_status_students = Student.objects.filter(
alumni_status=True)
elif alumni_status == "Current":
alumni_status_students = Student.objects.filter(
alumni_status=False)
else:
alumni_status_students = Student.objects.all()
if skills:
skills_students = Student.objects.filter(skills=skills)
else:
skills_students = Student.objects.all()
if min_graduation_date:
min_graduation_date_students = Student.objects.filter(
expected_graduation_date__gte=min_graduation_date)
else:
min_graduation_date_students = Student.objects.all()
if max_graduation_date:
max_graduation_date_students = Student.objects.filter(
expected_graduation_date__lte=max_graduation_date)
else:
max_graduation_date_students = Student.objects.all()
filtered_stds = skills_students & alumni_status_students & min_graduation_date_students & max_graduation_date_students
students_all = Student.objects.all()
students = students_all & filtered_stds
form = FilterStudentForm()
print("students", students)
args = {
'students': students,
'form': form,
'obj': user['obj'],
'user_type': user['user_type']
}
return render(request, "view_students.html", args)
elif user['user_type'] == 'employer' or user['user_type'] == 'admin':
students = Student.objects.all()
users = User.objects.all()
form = FilterStudentForm()
args = {
'students': students,
'obj': user['obj'],
'user_type': user['user_type'],
'form': form
}
else:
return redirect('/')
return render(request, 'view_students.html', args)
def news(request):
# news API to show the latest news
newsapi = NewsApiClient(api_key='1aab8f2e782a4a588fc28a3292a57979')
top = newsapi.get_top_headlines(sources='cnn')
l = top['articles']
desc = []
news = []
img = []
urllink = []
for i in range(len(l)):
f = l[i]
news.append(f['title'])
desc.append(f['description'])
img.append(f['urlToImage'])
urllink.append(f['url'])
mylist = list(zip(news, desc, img, urllink))
user = get_user_type(request)
args = {
'mylist': mylist,
'obj': user['obj'],
'user_type': user['user_type']
}
return render(request, 'news.html', args)
def student_details(request, id):
student = Student.objects.get(user_id=id)
user = get_user_type(request)
args = {
'student': student,
'obj': user['obj'],
'user_type': user['user_type']
}
return render(request, 'student_details.html', args)
def get(self, request, *args, **kwargs):
form = PostForm()
user = get_user_type(request)
args = {
'form': form,
'obj': user['obj'],
'user_type': user['user_type']
}
return render(request, self.template_name, args)
def my_applications(request):
user = get_user_type(request)
jobs_applied = StudentJobApplication.objects.filter(applied_id=user['obj'])
print(jobs_applied)
args = {
'jobs_applied': jobs_applied,
'obj': user['obj'],
'user_type': user['user_type']
}
return render(request, 'my_applications.html', args)
def get(self, request, *args, **kwargs):
c = HelpDeskModel.objects.filter(name_Request=request.user.id)
pending_requests = HelpDeskModel.objects.filter(
name_Request=request.user.id).order_by("completed")
user = get_user_type(request)
return render(
request, 'HelpDesk/my_helpdesk_requests.html', {
'helpdeskRequests': pending_requests,
'user_type': user['user_type'],
'obj': user['obj']
})
def job_details(request, id):
user = get_user_type(request)
job = Job.objects.get(id=id)
companies = Employer.objects.all()
args = {
'job': job,
'obj': user['obj'],
'user_type': user['user_type'],
'companies': companies,
'applied': True
}
form = StudentJobApplicationForm()
if request.method == 'POST':
if request.POST.get("apply"):
post = form.save(commit=False)
post.job_id = job
id = request.user.id
student = Student.objects.get(user_id=id)
post.applied = student
post.date_applied = timezone.now()
post.save()
return render(request, 'job_details.html', args)
elif request.POST.get("viewcandidates"):
candidates = StudentJobApplication.objects.filter(job_id=job)
print(candidates)
args = {
'candidates': candidates,
'obj': user['obj'],
'user_type': user['user_type']
}
return render(request, 'view_candidates.html', args)
try:
student = Student.objects.get(user_id=request.user.id)
job = Job.objects.get(id=id)
StudentJobApplication.objects.get(job_id_id=job, applied=student)
return render(request, 'job_details.html', args)
except:
args = {
'job': job,
'obj': user['obj'],
'user_type': user['user_type'],
'companies': companies,
'applied': False
}
return render(request, 'job_details.html', args)
def view_pending(request):
user = get_user_type(request)
applicants_students = Student.objects.filter(is_active='Pending')
applicants_alumni = Alumni.objects.filter(is_active='Pending')
applicants_employers = Employer.objects.filter(is_active='Pending')
args = {
'user_type': user['user_type'],
'applicants_students': applicants_students,
'applicants_alumni': applicants_alumni,
'applicants_employers': applicants_employers
}
return render(request, 'Admin/view_pending_requests.html', args)
def view_pend_acc_profile(request, id):
try:
student = Student.objects.get(user_id=id)
user = get_user_type(request)
args = {
'student': student,
'obj': user['obj'],
'user_type': user['user_type']
}
return render(request, 'Home/student_details.html', args)
except:
pass
try:
alumni = Alumni.objects.get(user_id=id)
user = get_user_type(request)
args = {
'alumni': alumni,
'obj': user['obj'],
'user_type': user['user_type']
}
return render(request, 'Home/alumni_details.html', args)
except:
pass
try:
employer = Employer.objects.get(user_id=id)
user = get_user_type(request)
args = {
'employer': employer,
'obj': user['obj'],
'user_type': user['user_type']
}
return render(request, 'Admin/view_employer_profile.html', args)
except:
pass
return redirect('view_pending_requests')
def generate_statistics(request):
user = get_user_type(request)
if request.method == "POST":
end_date = timezone.now()
time = request.POST.get('period')
if time == "Past 7 Days":
start_date = end_date - timedelta(6)
elif time == "Past 30 Days":
start_date = end_date - timedelta(29)
elif time == "Past Year":
start_date = end_date - timedelta(364)
users = User.objects.filter(date_joined__range=[start_date, end_date])
admins = Admin.objects.filter(user_id__in=User.objects.filter(date_joined__range=[start_date, end_date]))
admin_users = User.objects.filter(id__in=Admin.objects.all())
students = Student.objects.filter(user_id__in=User.objects.filter(date_joined__range=[start_date, end_date]))
current = Student.objects.filter(user_id__in=User.objects.filter(date_joined__range=[start_date, end_date]),
alumni_status=False)
alumni = Student.objects.filter(user_id__in=User.objects.filter(date_joined__range=[start_date, end_date]),
alumni_status=True)
employers = Employer.objects.filter(user_id__in=User.objects.filter(date_joined__range=[start_date, end_date])).exclude(user_id__in=admin_users)
jobs_posted = Job.objects.filter(date_posted__range=[start_date, end_date])
open_jobs = Job.objects.filter(date_posted__range=[start_date, end_date], status="Open")
closed_jobs = Job.objects.filter(date_posted__range=[start_date, end_date], status="Closed")
deleted_jobs = Job.objects.filter(date_posted__range=[start_date, end_date], status="Deleted")
apps = StudentJobApplication.objects.filter(date_applied__range=[start_date, end_date])
users = len(list(set(users)))
admins = len(list(set(admins)))
students = len(list(set(students)))
current = len(list(set(current)))
alumni = len(list(set(alumni)))
employers = len(list(set(employers)))
jobs_posted = len(list(set(jobs_posted)))
open_jobs = len(list(set(open_jobs)))
closed_jobs = len(list(set(closed_jobs)))
deleted_jobs = len(list(set(deleted_jobs)))
apps = len(list(set(apps)))
args = {'users': users, 'admins': admins, 'students': students, 'current': current, 'alumni': alumni, 'employers': employers,
'jobs_posted': jobs_posted, 'open_jobs': open_jobs, 'closed_jobs': closed_jobs,
'deleted_jobs': deleted_jobs, 'apps': apps, 'user_type': user['user_type'], 'obj': user['obj']}
return render(request, "admin/view_statistics.html", args)
else:
form = Statistics()
args = {'form': form, 'user_type': user['user_type'], 'obj': user['obj']}
return render(request, "admin/generate_statistics.html", args)
def edit_profile(request):
user = get_user_type(request)
if user['obj'] is not None:
if request.method == 'POST':
form = EmployerForm(request.POST, request.FILES, instance=user['obj'])
if form.is_valid():
form.save()
return redirect('view_employer_profile')
else:
messages.error(request, form.errors, extra_tags='danger')
return redirect('edit_employer_profile')
else:
form = EmployerForm(instance=user['obj'])
args = {'employer_form': form, 'obj': user['obj'], 'user_type': user['user_type']}
return render(request, 'Employer/edit_employer_profile.html', args)
else:
messages.error(request, 'This employer user does not exist')
def delete_job(request, id):
user = get_user_type(request)
job = Job.objects.get(id=id)
if request.method == 'POST':
job.status = 'Deleted'
job.save()
messages.success(request, "You have successfully deleted the job")
args = {'job': job, 'obj': user['obj'], 'user_type': user['user_type']}
return render(request, 'delete_job.html', args)
else:
form = EditJobForm()
args = {
'job': job,
'form': form,
'obj': user['obj'],
'user_type': user['user_type']
}
return render(request, 'delete_job.html', args)
def job_to_student_skills(request, id):
user = get_user_type(request)
job = Job.objects.get(id=id)
print(request.user)
students = Student.objects.filter(skills__in=job.skills.all())
students = list(set(students))
args = {
'students': students,
'form': FilterStudentForm(),
'obj': user['obj'],
'user_type': user['user_type']
}
message = Mail(
from_email='*****@*****.**',
to_emails=['*****@*****.**'],
subject='Student Skill match',
html_content=
"Student/Students having skills matching to your job have been found.")
sg = SendGridAPIClient(SENDGRID_API_KEY)
# sg.send(message)
return render(request, "view_students.html", args)
def view_pending_job_details(request, id):
user = get_user_type(request)
job = Job.objects.get(id=id)
companies = Employer.objects.all()
if request.POST.get("viewcandidates"):
alumniCandidates = AlumniJobApplication.objects.filter(job_id=job)
studentCandidates = StudentJobApplication.objects.filter(job_id=job)
args = {
'studentCandidates': studentCandidates,
'alumniCandidates': alumniCandidates,
'obj': user['obj'],
'user_type': user['user_type']
}
return render(request, 'Home/view_candidates.html', args)
args = {
'job': job,
'obj': user['obj'],
'user_type': user['user_type'],
'companies': companies,
'applied': True
}
return render(request, 'Admin/job_details.html', args)
def edit_profile(request):
args = get_user_type(request)
if args['obj'] is not None:
if request.method == 'POST':
form = EmployerForm(request.POST,
request.FILES,
instance=args['obj'])
if form.is_valid():
form.save()
return redirect('view_employer_profile')
else:
messages.info(request, form.errors)
return redirect("edit_employer_profile")
else:
form = EmployerForm(instance=args['obj'])
args = {
'employer_form': form,
'obj': args['obj'],
'user_type': args['user_type']
}
return render(request, 'edit_employer_profile.html', args)
else:
messages.info(request, 'This employer user does not exist')
def student_signup(request):
if request.method == 'POST':
user_form = InitialStudentForm(request.POST)
if user_form.is_valid():
if user_form.usernameExists(): #checks if username exists in db
messages.info(request,
'Username already taken. Try a different one.')
return redirect("student_registration")
elif user_form.emailExists(): #checks if email exists in db
messages.info(request,
'Email already taken. Try a different one.')
return redirect("student_registration")
elif number_symbol_exists(
user_form.cleaned_data["first_name"]
): #checks if number/symbol exists in string
messages.info(request, 'Please enter a valid first name.')
return redirect("student_registration")
elif number_symbol_exists(
user_form.cleaned_data["last_name"]
): #checks if number/symbol exists in string
messages.info(request, 'Please enter a valid last name.')
return redirect("student_registration")
elif not user_form.samePasswords(
): #checks if password and confirm password are matching
messages.info(request, 'Passwords not matching. Try again.')
return redirect("student_registration")
elif not user_form.emailDomainExists(
): #checks if there is an exising domain for given email
messages.info(request,
'Email domain does not exist. Try again.')
return redirect("student_registration")
else:
if isValidated(user_form.cleaned_data.get(
'password1')): #checks if password is valid
student_form = StudentForm(request.POST, request.FILES)
if student_form.is_valid():
email = user_form.cleaned_data["email"]
if not search("@student.murdoch.edu.au", email):
if not student_form.cleaned_data["alumni_status"]:
messages.info(
request,
'Please enter an existing murdoch student email.'
)
return redirect("student_registration")
else:
pass
with transaction.atomic():
user = user_form.save()
student = student_form.save(commit=False)
student.user = user
student.save()
student_form.save_m2m()
message = Mail(
from_email=DEFAULT_FROM_EMAIL,
to_emails=['*****@*****.**'],
subject='New User has signed up',
html_content=
"A new Student has registered to use the Murdoch Career Portal."
)
sg = SendGridAPIClient(SENDGRID_API_KEY)
# sg.send(message)
# notification = "A new Student has registered to use the Murdoch Career Portal."
# add_notif = UserNotifications(to_user_id=1, from_user_id=request.user.id,
# notification=notification,
# type='Sign Up',
# to_show=True)
# add_notif.save()
return redirect("log_in")
else:
messages.info(request, student_form.errors)
return redirect("student_registration")
else:
messages.info(
request,
'ERROR: Password must be 8 characters or more, and must have atleast 1 numeric character and 1 letter.'
)
return redirect("student_registration")
else:
messages.info(request, user_form.errors)
return redirect("student_registration")
else:
user_form = InitialStudentForm()
student_form = StudentForm()
user = get_user_type(request)
args = {
'student_form': student_form,
'user_form': user_form,
'user_type': user['user_type']
}
return render(request, 'student_registration.html', args)
def view_profile(request):
user = request.user
u = get_user_type(request)
args = {'user': user, 'user_type': u['user_type'], 'obj': u['obj']}
return render(request, 'view_student_profile.html', args)
def generate_student_statistics(request):
user = get_user_type(request)
if request.method == "POST":
start_date = request.POST.get('start_date')
end_date = request.POST.get('end_date')
end_date = datetime.datetime.strptime(
end_date, '%Y-%m-%d') + timedelta(hours=23, minutes=59, seconds=59)
major = request.POST.getlist("major")
skill = request.POST.getlist("skill")
users = User.objects.filter(date_joined__range=[start_date, end_date])
students = Student.objects.filter(user_id__in=users)
alumni = Alumni.objects.filter(user_id__in=users)
if major:
major_students = students.filter(majors__in=major)
major_alumni = alumni.filter(majors__in=major)
else:
major_students = students
major_alumni = alumni
if skill:
skill_students = students.filter(skills__in=skill)
skill_alumni = alumni.filter(skills__in=skill)
else:
skill_students = students
skill_alumni = alumni
filtered_students = major_students & skill_students
filtered_alumni = major_alumni & skill_alumni
accepted_students = filtered_students.filter(is_active='Accepted')
accepted_alumni = filtered_alumni.filter(is_active='Accepted')
pending_students = filtered_students.filter(is_active='Pending')
pending_alumni = filtered_alumni.filter(is_active='Pending')
rejected_students = filtered_students.filter(is_active='Rejected')
rejected_alumni = filtered_alumni.filter(is_active='Rejected')
filtered_students = len(list(set(filtered_students)))
filtered_alumni = len(list(set(filtered_alumni)))
accepted_students = len(list(set(accepted_students)))
accepted_alumni = len(list(set(accepted_alumni)))
pending_students = len(list(set(pending_students)))
pending_alumni = len(list(set(pending_alumni)))
rejected_students = len(list(set(rejected_students)))
rejected_alumni = len(list(set(rejected_alumni)))
args = {
'students': filtered_students,
'alumni': filtered_alumni,
'pending_students': pending_students,
'pending_alumni': pending_alumni,
'rejected_students': rejected_students,
'rejected_alumni': rejected_alumni,
'accepted_students': accepted_students,
'accepted_alumni': accepted_alumni,
'user_type': user['user_type'],
'obj': user['obj']
}
return render(request, "Admin/view_student_statistics.html", args)
else:
form = StudentStats()
args = {
'form': form,
'user_type': user['user_type'],
'obj': user['obj']
}
return render(request, "Admin/generate_statistics.html", args)
def generate_job_statistics(request):
user = get_user_type(request)
if request.method == "POST":
start_date = request.POST.get('start_date')
end_date = request.POST.get('end_date')
end_date = datetime.datetime.strptime(
end_date, '%Y-%m-%d') + timedelta(hours=23, minutes=59, seconds=59)
location = request.POST.get("location")
industry = request.POST.getlist("industry")
job_type = request.POST.get("job_type")
if location and location != "--Select--":
location_jobs = Job.objects.filter(
location=location, date_posted__range=[start_date, end_date])
else:
location_jobs = Job.objects.all()
if job_type and job_type != "---------":
job_type_jobs = Job.objects.filter(
job_type_id=job_type,
date_posted__range=[start_date, end_date])
else:
job_type_jobs = Job.objects.all()
if industry:
industry_jobs = Job.objects.filter(
industry_id__in=industry,
date_posted__range=[start_date, end_date])
else:
industry_jobs = Job.objects.all()
filtered_jobs = location_jobs & job_type_jobs & industry_jobs
normal_jobs = filtered_jobs.exclude(job_type_id=JOB_ID)
open_jobs = get_total_jobs(
normal_jobs.filter(status="Open", is_active='Accepted'))
closed_jobs = get_total_jobs(
normal_jobs.filter(status="Closed", is_active='Accepted'))
deleted_jobs = get_total_jobs(
normal_jobs.filter(status="Deleted", is_active='Accepted'))
pending_jobs = get_total_jobs(
normal_jobs.filter(date_posted__range=[start_date, end_date],
is_active='Pending'))
rejected_jobs = get_total_jobs(
normal_jobs.filter(date_posted__range=[start_date, end_date],
is_active='Rejected'))
total_internships_posted = get_total_jobs(
filtered_jobs.filter(job_type_id=JOB_ID))
open_internships = get_total_jobs(
filtered_jobs.filter(job_type_id=JOB_ID,
status='Open',
is_active='Accepted'))
closed_internships = get_total_jobs(
filtered_jobs.filter(job_type_id=JOB_ID,
status='Closed',
is_active='Accepted'))
deleted_internships = get_total_jobs(
filtered_jobs.filter(job_type_id=JOB_ID,
status='Deleted',
is_active='Accepted'))
pending_internships = get_total_jobs(
filtered_jobs.filter(job_type_id=JOB_ID,
date_posted__range=[start_date, end_date],
is_active='Pending'))
rejected_internships = get_total_jobs(
filtered_jobs.filter(job_type_id=JOB_ID,
date_posted__range=[start_date, end_date],
is_active='Rejected'))
total_jobs = get_total_jobs(filtered_jobs)
total_accepted_jobs = open_jobs + closed_jobs + deleted_jobs
total_accepted_internships = open_internships + closed_internships + deleted_internships
args = {
'total_jobs': total_jobs,
'total_accepted_jobs': total_accepted_jobs,
'open_jobs': open_jobs,
'closed_jobs': closed_jobs,
'deleted_jobs': deleted_jobs,
'pending_jobs': pending_jobs,
'total_internships_posted': total_internships_posted,
'total_accepted_internships': total_accepted_internships,
'open_internships': open_internships,
'closed_internships': closed_internships,
'deleted_internships': deleted_internships,
'pending_internships': pending_internships,
'rejected_internships': rejected_internships,
'rejected_jobs': rejected_jobs,
'user_type': user['user_type'],
'obj': user['obj']
}
return render(request, "Admin/view_job_statistics.html", args)
else:
form = JobStats()
args = {
'form': form,
'user_type': user['user_type'],
'obj': user['obj']
}
return render(request, "Admin/generate_statistics.html", args)
def generate_statistics(request):
user = get_user_type(request)
if request.method == "POST":
normal_jobs = Job.objects.exclude(job_type_id=JOB_ID)
start_date = request.POST.get('start_date')
end_date = request.POST.get('end_date')
end_date = datetime.datetime.strptime(
end_date, '%Y-%m-%d') + timedelta(hours=23, minutes=59, seconds=59)
admins = Admin.objects.filter(user_id__in=User.objects.filter(
date_joined__range=[start_date, end_date]))
admin_users = User.objects.filter(id__in=Admin.objects.all())
current = Student.objects.filter(
is_active='Accepted',
user_id__in=User.objects.filter(
date_joined__range=[start_date, end_date]))
alumni = Alumni.objects.filter(
is_active='Accepted',
user_id__in=User.objects.filter(
date_joined__range=[start_date, end_date]))
employers = Employer.objects.filter(
is_active='Accepted',
user_id__in=User.objects.filter(
date_joined__range=[start_date, end_date])).exclude(
user_id__in=admin_users)
jobs_posted = get_total_jobs(
normal_jobs.filter(date_posted__range=[start_date, end_date],
is_active='Accepted'))
open_jobs = get_total_jobs(
normal_jobs.filter(date_posted__range=[start_date, end_date],
status="Open",
is_active='Accepted'))
closed_jobs = get_total_jobs(
normal_jobs.filter(date_posted__range=[start_date, end_date],
status="Closed",
is_active='Accepted'))
deleted_jobs = get_total_jobs(
normal_jobs.filter(date_posted__range=[start_date, end_date],
status="Deleted",
is_active='Accepted'))
internships_posted = get_total_jobs(
Job.objects.filter(job_type_id_id=JOB_ID, is_active='Accepted'))
apps = StudentJobApplication.objects.filter(
date_applied__range=[start_date, end_date])
alumni_apps = AlumniJobApplication.objects.filter(
date_applied__range=[start_date, end_date])
pending_employers = Employer.objects.filter(
is_active='Pending',
user_id__in=User.objects.filter(
date_joined__range=[start_date, end_date])).exclude(
user_id__in=admin_users)
pending_students = Student.objects.filter(
is_active='Pending',
user_id__in=User.objects.filter(
date_joined__range=[start_date, end_date]))
pending_alumni = Alumni.objects.filter(
is_active='Pending',
user_id__in=User.objects.filter(
date_joined__range=[start_date, end_date]))
rejected_employers = Employer.objects.filter(
is_active='Rejected',
user_id__in=User.objects.filter(
date_joined__range=[start_date, end_date])).exclude(
user_id__in=admin_users)
rejected_students = Student.objects.filter(
is_active='Rejected',
user_id__in=User.objects.filter(
date_joined__range=[start_date, end_date]))
rejected_alumni = Alumni.objects.filter(
is_active='Rejected',
user_id__in=User.objects.filter(
date_joined__range=[start_date, end_date]))
pending_jobs = get_total_jobs(
normal_jobs.filter(date_posted__range=[start_date, end_date],
is_active='Pending'))
rejected_jobs = get_total_jobs(
normal_jobs.filter(date_posted__range=[start_date, end_date],
is_active='Rejected'))
total_users = User.objects.filter(
date_joined__range=[start_date, end_date])
total_users = len(list(set(total_users)))
admins = len(list(set(admins)))
current = len(list(set(current)))
alumni = len(list(set(alumni)))
employers = len(list(set(employers)))
apps = len(list(set(apps)))
alumni_apps = len(list(set(alumni_apps)))
pending_employers = len(list(set(pending_employers)))
pending_students = len(list(set(pending_students)))
pending_alumni = len(list(set(pending_alumni)))
rejected_employers = len(list(set(rejected_employers)))
rejected_students = len(list(set(rejected_students)))
rejected_alumni = len(list(set(rejected_alumni)))
pending_users = pending_employers + pending_students + pending_alumni
rejected_users = rejected_employers + rejected_students + rejected_alumni
users = admins + current + alumni + employers
students = current + alumni
args = {
'users': users,
'admins': admins,
'students': students,
'current': current,
'alumni': alumni,
'employers': employers,
'pending_users': pending_users,
'pending_jobs': pending_jobs,
'jobs_posted': jobs_posted,
'open_jobs': open_jobs,
'closed_jobs': closed_jobs,
'internships_posted': internships_posted,
'total_users': total_users,
'deleted_jobs': deleted_jobs,
'apps': apps,
'alumni_apps': alumni_apps,
'rejected_users': rejected_users,
'rejected_jobs': rejected_jobs,
'user_type': user['user_type'],
'obj': user['obj']
}
return render(request, "Admin/view_statistics.html", args)
else:
form = Statistics()
args = {
'form': form,
'user_type': user['user_type'],
'obj': user['obj']
}
return render(request, "Admin/generate_statistics.html", args)
def student_signup(request):
if request.method == 'POST':
user_data = {
'first_name': request.POST.get('first_name'),
'last_name': request.POST.get('last_name'),
'email': request.POST.get('email')
}
student_data = {
'gender':
request.POST.get('gender'),
'date_of_birth':
request.POST.get('date_of_birth'),
'student_id':
request.POST.get('student_id'),
'expected_graduation_date':
request.POST.get('expected_graduation_date'),
'personal_email':
request.POST.get('personal_email'),
'skills':
request.POST.getlist('skills'),
'majors':
request.POST.getlist('majors'),
'dp':
request.FILES.get('dp'),
'cv':
request.FILES.get('cv')
}
user_form = InitialStudentForm(request.POST)
if user_form.is_valid():
if user_form.usernameExists():
messages.error(
request,
'Username already taken. Try a different one.',
extra_tags='danger') # checks if username exists in db
elif user_form.emailExists():
messages.error(
request,
'Email already taken. Try a different one.',
extra_tags='danger') # checks if email exists in db
elif not user_form.same_passwords():
messages.error(
request,
'Passwords not matching. Try again.',
extra_tags='danger'
) # checks if password and confirm password are matching
elif not user_form.email_domain_exists():
messages.error(
request,
'Email domain does not exist. Try again.',
extra_tags='danger'
) # checks if there is an existing domain for given email
else:
if isValidated(user_form.cleaned_data.get('password1')):
student_form = StudentForm(request.POST, request.FILES)
if student_form.is_valid():
with transaction.atomic():
user = user_form.save()
student = student_form.save(commit=False)
student.user = user
email = str(student.user)
student_email = str(student.personal_email)
student.save()
student_form.save_m2m()
first_name = user_form.cleaned_data.get(
'first_name')
context = {'first_name': first_name}
admin_context = {
'first_name': first_name,
'protocol': 'https',
'domain': 'murdochdubaicareerportal.com'
}
subject = 'Your account creation request has been received'
htmlText = render_to_string(
'Accounts/account_creation_request.html',
context)
send_html_mail(subject, htmlText, [email])
send_html_mail(subject, htmlText, [student_email])
subject = 'An account creation request has been received '
htmlText = render_to_string(
'Accounts/account_creation_request_admin.html',
admin_context)
send_html_mail(subject, htmlText,
[DEFAULT_FROM_EMAIL])
messages.success(request,
'A student account has been created')
return render(request, 'Accounts/pending_acc.html',
get_user_type(request))
else:
messages.error(request,
student_form.errors,
extra_tags='danger')
else:
messages.error(
request,
'Password must be 8 characters or more, and must have at least 1 numeric character '
'and 1 letter.',
extra_tags='danger')
else:
messages.error(request, user_form.errors, extra_tags='danger')
user_form = InitialStudentForm(user_data)
student_form = StudentForm(student_data)
else:
user_form = InitialStudentForm()
student_form = StudentForm()
user = get_user_type(request)
args = {
'student_form': student_form,
'user_form': user_form,
'user_type': user['user_type']
}
return render(request, 'Student/student_registration.html', args)
def view_alumni_profile(request, id):
user = get_user_type(request)
alumni = Alumni.objects.get(user_id=id)
args = {'alumni': alumni, 'user_type': user['user_type']}
return render(request, 'Home/alumni_details.html', args)
def view_student_profile(request, id):
user = get_user_type(request)
student = Student.objects.get(user_id=id)
args = {'student': student, 'user_type': user['user_type']}
return render(request, 'Home/student_details.html', args)
def view_employer_profile(request, id):
user = get_user_type(request)
employer = Employer.objects.get(user_id=id)
args = {'employer': employer, 'user_type': user['user_type']}
return render(request, 'Admin/view_employer_profile.html', args)
def view_pending_jobs(request):
user = get_user_type(request)
jobs = Job.objects.filter(is_active='Pending')
args = {'user_type': user['user_type'], 'jobs': jobs}
return render(request, 'Admin/view_pending_jobs.html', args)
def AllPosts(request):
posts = Post.objects.filter(status=True).order_by('-release_date')
user = get_user_type(request)
args = {'posts': posts, 'obj': user['obj'], 'user_type': user['user_type']}
return render(request, 'bulletin/allPosts.html', args)
def activate(request):
user = get_user_type(request)
return render(request, 'Employer/pending_activation.html', user)
