def staff_view(request, id):
loggedin_user = request.user
loggedin_staff = Staff.objects.get(user=loggedin_user)
try:
staff = Staff.objects.get(pk=id)
except Staff.DoesNotExist:
pass
if loggedin_user.is_staff or loggedin_staff.department.lower(
) == "it" or loggedin_staff.it_department_access:
event.create_event(request, request.user, f"Viewed staff profile {id}")
all_events = event.get_my_events(request, staff.user)
gen_event = len(event.get_events(request))
all_events_num = len(all_events)
if all_events_num > 5:
events = all_events[all_events_num - 5:all_events_num]
else:
events = all_events
return render(
request, "main/staff.html", {
"staff": staff,
"events": reversed(events),
"event_num": all_events_num,
"all_events": reversed(all_events),
"gen_event": gen_event
})
return HttpResponseRedirect(reverse("noaccess"))
def dashboard_view(request):
loggedin_user = request.user
loggedin_staff = Staff.objects.get(user=loggedin_user)
if request.user.is_staff or loggedin_staff.department.lower(
) == "director" or loggedin_staff.director_access:
event.create_event(request, request.user,
"Accessed Director Dashboard")
invoices = StudentInvoice.objects.all()
total_payment_recieved = 0
total_payment_balance = 0
num_of_intl_students = 0
num_of_local_students = 0
num_of_applications = len(Student.objects.filter(hasOffer=False))
num_of_all_students = len(Student.objects.filter(hasOffer=True))
for invoice in invoices:
total_payment_recieved += invoice.amount
total_payment_balance += invoice.balance
event_num = len(event.get_events(request))
enrolled_students = EnrolledStudent.objects.all()
enrolled_num = len(enrolled_students)
for student in enrolled_students:
if student.student.isInternationalStudent:
num_of_intl_students += 1
else:
num_of_local_students += 1
events = event.get_events(request)
return render(
request, "main/dashboard.html", {
"num_of_events": event_num,
"num_of_enrolled": enrolled_num,
"total_payment_recieved": total_payment_recieved,
"total_payment_balance": total_payment_balance,
"num_of_intl_students": num_of_intl_students,
"num_of_local_students": num_of_local_students,
"num_of_applications": num_of_applications,
"num_of_all_students": num_of_all_students,
"events": reversed(events)
})
else:
event.create_event(request, request.user,
"Tried to access director dashboard")
return HttpResponseRedirect(reverse("noaccess"))
def invoices_view(request):
loggedin_user = request.user
loggedin_staff = Staff.objects.get(user=loggedin_user)
if loggedin_user.is_staff or loggedin_staff.director_access or loggedin_staff.student_finance_access or loggedin_staff.department.lower(
) == "finance":
event.create_event(request, request.user, f"Accessed invoices")
invoices = StudentInvoice.objects.all()
return render(request, "main/invoices.html", {"invoices": invoices})
else:
event.create_event(request, request.user, f"Tried to acces Invoices")
return HttpResponseRedirect(reverse("noaccess"))
def discount_reg_view(request):
loggedin_user = request.user
loggedin_staff = Staff.objects.get(user=loggedin_user)
if loggedin_user.is_staff or loggedin_staff.student_admission_access or loggedin_staff.department.lower(
) == "admission":
if request.method == "GET":
event.create_event(
request, request.user,
"Accessed Discount and Scholarship Registration Page")
return render(request, "main/discount_register.html")
if request.method == "POST":
event.create_event(request, request.user,
"Tried to register Discount or Scholarship")
discount_code = request.POST["discount-code"]
discount_title = request.POST["discount-title"]
discount_desc = request.POST["discount-desc"]
discount_percent = request.POST["discount-percent"]
try:
new_discount = DiscountsAndScholarship(
code=discount_code,
title=discount_title,
description=discount_desc,
percent=discount_percent)
new_discount.save()
event.create_event(request, request.user,
"Created a new discount or scholarship")
return HttpResponseRedirect(
reverse("discount", args=(new_discount.id, )))
except IntegrityError:
event.create_event(
request, request.user,
"Failed to register Discount or Scholarship")
return HttpResponseRedirect("discount-register")
else:
event.create_event(
request, request.user,
"Tried to Access Discount and Scholarship Registration Page")
return HttpResponseRedirect(reverse("noaccess"))
def programme_reg_view(request):
loggedin_user = request.user
loggedin_staff = Staff.objects.get(user=loggedin_user)
if request.user.is_staff or loggedin_staff.department.lower(
) == "it" or loggedin_staff.it_department_access:
event.create_event(request, request.user,
"Accessed Programme Registration Page")
modules = Module.objects.all()
if request.method == "GET":
return render(request, "main/programme_register.html",
{"modules": modules})
if request.method == "POST":
code = request.POST["programme-code"]
title = request.POST["programme-title"]
desc = request.POST["programme-desc"]
modules = request.POST.getlist("modules")
fee = request.POST["programme-fee"]
try:
programme = Programme(code=code,
title=title,
description=desc,
fee=int(fee))
programme.save()
for module in modules:
modul = Module.objects.get(pk=int(module))
programme.modules.add(modul)
programme.save()
event.create_event(request, request.user,
"Created a new programme")
except IntegrityError:
event.create_event(request, request.user,
"Tried to create a new Programme")
return HttpResponse("Failed to create a new programme")
return HttpResponseRedirect(
reverse("programme", args=(programme.id, )))
else:
event.create_event(request, request.user,
"Tried to access programme registration page")
return HttpResponseRedirect(reverse("noaccess"))
def modules_view(request):
loggedin_user = request.user
loggedin_staff = Staff.objects.get(user=loggedin_user)
if loggedin_user.is_staff or loggedin_staff.department.lower(
) == "it" or loggedin_staff.it_department_access:
event.create_event(request, request.user, f"Viewed modules page")
modules = Module.objects.all()
return render(request, "main/modules.html", {
"modules": modules,
})
else:
event.create_event(request, request.user,
f"Tried to view modules page")
return HttpResponseRedirect(reverse("noaccess"))
def programmes_view(request):
loggedin_user = request.user
loggedin_staff = Staff.objects.get(user=loggedin_user)
if request.user.is_staff or loggedin_staff.department.lower(
) == "it" or loggedin_staff.it_department_access:
event.create_event(request, request.user, f"Accessed Programmes Page")
programmes = Programme.objects.all()
return render(request, "main/programmes.html", {
"programmes": programmes,
})
else:
event.create_event(request, request.user,
f"Tried to access programmes page")
return HttpResponseRedirect(reverse("noaccess"))
def staffs_view(request):
loggedin_user = request.user
loggedin_staff = Staff.objects.get(user=loggedin_user)
if loggedin_user.is_staff or loggedin_staff.department.lower(
) == "it" or loggedin_staff.it_department_access:
if request.method == "GET":
event.create_event(request, request.user, "Accessed Staffs Page")
try:
staffs = Staff.objects.all()
except Staff.DoesNotExist:
staffs = []
return render(request, "main/staffs.html", {"staffs": staffs})
return HttpResponseRedirect(reverse("noaccess"))
def discounts_view(request):
loggedin_user = request.user
loggedin_staff = Staff.objects.get(user=loggedin_user)
if loggedin_user.is_staff or loggedin_staff.student_admission_access or loggedin_staff.department.lower(
) == "admission":
event.create_event(request, request.user,
f"Accessed Discounts and Scholarships")
try:
discounts = DiscountsAndScholarship.objects.all()
except:
return HttpResponse("Does not exist")
return render(request, "main/discounts.html", {"discounts": discounts})
else:
event.create_event(request, request.user,
f"Tried to Access Discounts and Scholarships Page")
return HttpResponseRedirect(reverse("noaccess"))
def students_view(request):
loggedin_user = request.user
loggedin_staff = Staff.objects.get(user=loggedin_user)
if loggedin_user.is_staff or loggedin_staff.student_admission_access or loggedin_staff.director_access or loggedin_staff.department.lower(
) == "admission":
event.create_event(request, request.user,
f"Accessed student admission cards page")
try:
students = Student.objects.all()
except:
return HttpResponse("Student profile does not exist!")
return render(request, "main/students.html", {"students": students})
else:
event.create_event(request, request.user,
f"Tried to access student admission cards")
return HttpResponseRedirect(reverse("noaccess"))
def enroll_register_view(request):
loggedin_user = request.user
loggedin_staff = Staff.objects.get(user=loggedin_user)
if loggedin_user.is_staff or loggedin_staff.director_access or loggedin_staff.student_office_department_access or loggedin_staff.department.lower(
) == "student office":
if request.method == "GET":
event.create_event(request, request.user,
"Accessed student enrollment portal")
students = Student.objects.all()
programmes = Programme.objects.all()
return render(request, "main/enroll_register.html", {
"students": students,
"programmes": programmes
})
else:
event.create_event(request, request.user,
"Tried to access student enrollment portal")
return HttpResponseRedirect(reverse("noaccess"))
def programme_view(request, id):
loggedin_user = request.user
loggedin_staff = Staff.objects.get(user=loggedin_user)
if request.user.is_staff or loggedin_staff.department.lower(
) == "it" or loggedin_staff.it_department_access:
event.create_event(request, request.user, f"Accessed Programme {id}")
programme = Programme.objects.get(pk=id)
return render(
request, "main/programme.html", {
"programme": programme,
"programme_module_num": programme.modules.count()
})
else:
event.create_event(request, request.user,
f"Tried to access programme {id}")
return HttpResponseRedirect(reverse("noaccess"))
def module_view(request, id):
loggedin_user = request.user
loggedin_staff = Staff.objects.get(user=loggedin_user)
if loggedin_user.is_staff or loggedin_staff.department.lower(
) == "it" or loggedin_staff.it_department_access:
event.create_event(request, request.user, f"Viewed module {id}")
try:
module = Module.objects.get(pk=id)
except Module.DoesNotExist:
pass
return render(request, "main/module.html", {
"module": module,
"module_tutor_num": module.tutors.count()
})
else:
event.create_event(request, request.user, f"Tried to view module {id}")
return HttpResponseRedirect(reverse("noaccess"))
def invoice_reg_view(request):
loggedin_user = request.user
loggedin_staff = Staff.objects.get(user=loggedin_user)
if loggedin_user.is_staff or loggedin_staff.director_access or loggedin_staff.student_finance_access or loggedin_staff.department.lower(
) == "finance":
if request.method == "GET":
event.create_event(request, request.user,
"Accessed Invoice Generation Portal")
students = Student.objects.all()
return render(request, "main/invoice_register.html",
{"students": students})
if request.method == "POST":
event.create_event(request, request.user,
"Tried to create a new invoice")
student = request.POST["student"]
year = request.POST["year"]
amount = request.POST["amount"]
def calculate_balance(student_id, amount):
try:
student = Student.objects.get(pk=student_id)
except:
return None
if StudentPayments.objects.filter(student=student).exists():
total_in_invoices = 0
for invoice in StudentPayments.objects.get(
student=student).invoices.all():
total_in_invoices += invoice.amount
student_programme = student.programme_application
balance = student_programme.fee - total_in_invoices
else:
student_programme = student.programme_application
balance = student_programme.fee - amount
return balance
def calculate_hold(student_id, amount):
try:
student = Student.objects.get(pk=student_id)
except:
return None
if StudentPayments.objects.filter(student=student).exists():
total_in_invoices = 0
for invoice in StudentPayments.objects.get(
student=student).invoices.all():
total_in_invoices += invoice.amount
student_programme = student.programme_application
if total_in_invoices > student_programme.fee:
balance = total_in_invoices - student_programme.fee
else:
balance = 0
else:
student_programme = student.programme_application
if amount > student_programme.fee:
balance = amount - student_programme.fee
else:
balance = 0
return balance
try:
new_invoice = StudentInvoice(
student=Student.objects.get(pk=int(student)),
academic_year=year,
amount=int(amount),
balance=calculate_balance(int(student), int(amount))
if calculate_balance(int(student), int(amount)) != None
else -10000000000.0,
finance_hold=calculate_hold(int(student), int(amount))
if calculate_hold(int(student), int(amount)) != None else
-10000000000.0)
new_invoice.save()
event.create_event(request, request.user,
f"Created a new invoice {new_invoice.id}")
except IntegrityError:
event.create_event(request, request.user,
"Tried to generate new invoice")
return HttpResponse("Unable to generate invoice")
student = Student.objects.get(pk=int(student))
try:
payment_record = StudentPayments.objects.get(student=student)
payment_record.invoices.add(new_invoice)
payment_record.save()
total_amount = 0
for invoice in payment_record.invoices.all():
total_amount += invoice.amount
programme_fee = payment_record.student.programme_application.fee
total_discounts_percent = 0
for discount in payment_record.student.DiscountOrScholarship.all(
):
total_discounts_percent += discount.percent
#Check this steps
programme_fee_after_discount = programme_fee - (
programme_fee / 100 * total_discounts_percent)
percent_paid = total_amount / programme_fee_after_discount * 100
payment_record.percent = percent_paid
payment_record.save()
except StudentPayments.DoesNotExist:
new_payment_record = StudentPayments(
student=student,
percent=0,
academic_year=year,
)
new_payment_record.save()
new_payment_record.invoices.add(new_invoice)
new_payment_record.save()
total_amount = 0
for invoice in new_payment_record.invoices.all():
total_amount += invoice.amount
programme_fee = new_payment_record.student.programme_application.fee
total_discounts_percent = 0
for discount in new_payment_record.student.DiscountOrScholarship.all(
):
total_discounts_percent += discount.percent
programme_fee_after_discount = programme_fee - (
programme_fee / 100 * total_discounts_percent)
percent_paid = total_amount / programme_fee_after_discount * 100
new_payment_record.percent = percent_paid
new_payment_record.save()
return HttpResponseRedirect(
reverse("invoice", args=(new_invoice.id, )))
else:
event.create_event(request, request.user,
"Tried to acces Invoice Generation Portal")
return HttpResponseRedirect(reverse("noaccess"))
def module_reg_view(request):
loggedin_user = request.user
loggedin_staff = Staff.objects.get(user=loggedin_user)
if request.method == "GET":
if loggedin_user.is_staff or loggedin_staff.department.lower(
) == "it" or loggedin_staff.it_department_access:
event.create_event(request, request.user,
"Viewed Module Creation Page")
return render(request, "main/module_register.html",
{"tutors": Staff.objects.all()})
event.create_event(request, request.user,
"Tried to View Module Creation Page")
return HttpResponseRedirect(reverse("noaccess"))
if request.method == "POST":
if loggedin_user.is_staff or loggedin_staff.department.lower(
) == "it" or loggedin_staff.it_department_access:
event.create_event(request, request.user,
"Tried to create a new module")
code = request.POST["module-code"]
title = request.POST["module-title"]
desc = request.POST["module-desc"]
tutors = request.POST.getlist("tutors")
try:
module = Module(code=code, title=title, description=desc)
module.save()
for tutor in tutors:
staff = Staff.objects.get(pk=int(tutor))
module.tutors.add(staff)
module.save()
event.create_event(request, request.user,
"Created a new module")
except IntegrityError:
event.create_event(request, request.user,
"Failed to create a new module")
return HttpResponse("Failed to create a new module")
return HttpResponseRedirect(reverse("module", args=(module.id, )))
else:
event.create_event(request, request.user,
"Tried to create a new module")
return HttpResponseRedirect(reverse("noaccess"))
def student_reg_view(request):
loggedin_user = request.user
loggedin_staff = Staff.objects.get(user=loggedin_user)
if loggedin_user.is_staff or loggedin_staff.student_admission_access or loggedin_staff.director_access or loggedin_staff.department.lower(
) == "admission":
if request.method == "GET":
discounts_and_scholarships = DiscountsAndScholarship.objects.all()
programmes = Programme.objects.all()
event.create_event(request, request.user,
"Accessed Student Creation Page")
return render(request, "main/student_register.html", {
"discounts": discounts_and_scholarships,
"programmes": programmes
})
if request.method == "POST":
event.create_event(request, request.user,
"Tried to create a new student")
first_name = request.POST["first-name"]
lasst_name = request.POST["last-name"]
sex = request.POST["sex"]
email = request.POST["email"]
phone = request.POST["phone"]
address = request.POST["address"]
country = request.POST["country"]
is_international = request.POST.get("is-international")
programme = request.POST["programme"]
has_offer = request.POST.get("has-offer")
discounts = request.POST.getlist("discounts")
try:
new_student = Student(
first_name=first_name,
last_name=lasst_name,
sex=sex,
phone=phone,
email=email,
country=country,
address=address,
isInternationalStudent=True
if is_international == "on" else False,
programme_application=Programme.objects.get(
pk=int(programme)),
hasOffer=True if has_offer == "on" else False,
)
new_student.save()
event.create_event(request, request.user,
f"Created student {new_student.id}")
if len(discounts) > 0:
for discount in discounts:
discount_object = DiscountsAndScholarship.objects.get(
pk=int(discount))
new_student.DiscountOrScholarship.add(discount_object)
new_student.save()
except IntegrityError:
event.create_event(request, request.user,
"Tried to create a new student")
return HttpResponse("Failed to create a new user")
return HttpResponseRedirect(
reverse("student", args=(new_student.id, )))
else:
event.create_event(request, request.user,
"Tried to access student creation page")
return HttpResponseRedirect(reverse("noaccess"))
def register_view(request):
if request.method == "GET":
event.create_event(request, request.user, "Opened Staff Creation Page")
user = request.user
try:
staff = Staff.objects.get(user=user)
except Staff.DoesNotExist:
return HttpResponseRedirect(reverse("noaccess"))
if user.is_staff or staff.department.lower(
) == "it" or staff.it_department_access:
return render(request, "main/register.html")
return HttpResponseRedirect(reverse("noaccess"))
if request.method == "POST":
username = request.POST["username"]
first_name = request.POST["first-name"]
last_name = request.POST["last-name"]
password = request.POST["password"]
email = request.POST["email"]
degree = request.POST["degree"]
phone = request.POST["phone"]
department = request.POST["department"]
specialization = request.POST["specialization"]
sex = request.POST["sex"]
job = request.POST["job"]
it_department_access = request.POST.get("it-access")
student_office_department_access = request.POST.get(
"student-office-access")
student_visa_access = request.POST.get("visa-access")
student_finance_access = request.POST.get("finance-access")
student_admission_access = request.POST.get("admission-access")
director_access = request.POST.get("director-access")
if User.objects.filter(username=username).exists():
return HttpResponse("Username taken")
if first_name == "" or last_name == "" or password == "" or email == "" or phone == "" or department == "" or specialization == "" or sex == "" or job == "":
return HttpResponse("Fields cant be empty!")
try:
user = User.objects.create_user(username=username,
email=email,
password=password,
first_name=first_name,
last_name=last_name)
user.save()
event.create_event(request, request.user,
f"Registered a new user with id {user.id}")
except IntegrityError:
event.create_event(request, request.user, "Tried to create a user")
return HttpResponse("Error creating staff, try again later")
try:
staff = Staff(
user=user,
sex=sex,
phone=phone,
degree=degree,
specialization=specialization,
department=department,
job=job,
it_department_access=True
if it_department_access == "on" else False,
student_office_department_access=True
if student_office_department_access == "on" else False,
student_visa_access=True
if student_visa_access == "on" else False,
student_finance_access=True
if student_finance_access == "on" else False,
student_admission_access=True
if student_admission_access == "on" else False,
director_access=True if director_access == "on" else False)
staff.save()
event.create_event(request, request.user,
f"Registered a new staff with id {staff.id}")
except IntegrityError:
event.create_event(request, request.user,
"Tried to create a staff")
return HttpResponse(
"User created, unable to create staff, pls use username to create a new staff"
)
return HttpResponseRedirect(reverse("staff", args=(staff.id, )))
