Merge pull request #1659 from dvjsharma/dashboard_client

chore(Release): Dashboard Client sync with Latest Staging

FusionIIIT/Fusion/settings/common.py

@@ -284,3 +284,8 @@
 
 CORS_ORIGIN_ALLOW_ALL = True
 ALLOW_PASS_RESET = True
+
+# session settings
+SESSION_COOKIE_AGE = 15 * 60
+SESSION_EXPIRE_AT_BROWSER_CLOSE = True
+SESSION_SAVE_EVERY_REQUEST = True

FusionIIIT/applications/academic_information/forms.py

@@ -1,6 +1,6 @@
 from django import forms
 
-from .models import Exam_timetable, Meeting, Timetable
+from .models import Exam_timetable, Meeting, Timetable, Student
 
 
 class MinuteForm(forms.ModelForm):
@@ -49,3 +49,15 @@ class ExamTimetableForm(forms.ModelForm):
     class Meta:
         model = Exam_timetable
         fields = ('programme', 'exam_time_table',)
+
+
+class PreRegistrationSearchForm(forms.Form):
+    roll_no = forms.CharField(
+        max_length=20,
+        widget=forms.TextInput(attrs={'class': 'ui input', 'placeholder': 'Enter Roll Number'}),
+        label="Roll Number"
+    )
+    semester_no = forms.IntegerField(
+        widget=forms.NumberInput(attrs={'class': 'ui input', 'placeholder': 'Enter Semester No'}),
+        label="Semester No"
+    )

FusionIIIT/applications/academic_information/urls.py

@@ -43,4 +43,5 @@
     url(r'^api/',include('applications.academic_information.api.urls')),
     url(r'^view_all_student_data', views.view_all_student_data, name='view_all_student_data'),
     url(r'^generateStudentSheet$',views.generatestudentxlsheet, name = 'generatestudentxlsheet'),
+    url(r'^course_allocated_students$',views.get_excel, name = 'course_allocated_students'),
 ]

FusionIIIT/applications/academic_information/utils.py

@@ -0,0 +1,165 @@
+from applications.academic_information.models import (Calendar, Student,Curriculum_Instructor, Curriculum,
+                                                      Student_attendance)
+from ..academic_procedures.models import (BranchChange, CoursesMtech, InitialRegistration, StudentRegistrationChecks,
+                     Register, Thesis, FinalRegistration, ThesisTopicProcess,
+                     Constants, FeePayments, TeachingCreditRegistration, SemesterMarks, 
+                     MarkSubmissionCheck, Dues,AssistantshipClaim, MTechGraduateSeminarReport,
+                     PhDProgressExamination,CourseRequested, course_registration, MessDue, Assistantship_status , backlog_course,)
+
+from applications.programme_curriculum.models import(Course,CourseSlot,Batch,Semester)
+from django.http import HttpResponse, JsonResponse
+from django.utils import timezone
+from django.core import serializers
+from django.db.models import Q
+import datetime
+import random
+from django.db import transaction
+time = timezone.now()
+def check_for_registration_complete (request):
+    batch = int(request.POST.get('batch'))
+    sem = int(request.POST.get('sem'))
+    year = request.POST.get('year')
+
+
+    date = time.date()
+
+    try:
+
+        pre_registration_date = Calendar.objects.all().filter(description=f"Pre Registration {sem} {year}").first()
+        prd_start_date = pre_registration_date.from_date
+        prd_end_date = pre_registration_date.to_date
+
+        if date<prd_start_date : 
+            return JsonResponse({'status':-2 , 'message': "registration didn't start"})
+        if date>=prd_start_date and date<=prd_end_date:
+            return JsonResponse({'status':-1 , "message":"registration is under process"})
+
+        if FinalRegistration.objects.filter(Q(semester_id__semester_no = sem) & Q(student_id__batch = batch)).exists() : 
+            return JsonResponse({'status':2,"message":"courses already allocated"})
+
+        return JsonResponse({"status":1 , "message" : "courses not yet allocated"})
+    except :
+        return JsonResponse({"status":-3, "message" : "No such registration found"})
+
+@transaction.atomic
+def random_algo(batch,sem,year,course_slot) :
+    unique_course = InitialRegistration.objects.filter(Q(semester_id__semester_no = sem) & Q( course_slot_id__name = course_slot ) & Q(student_id__batch = batch)).values_list('course_id',flat=True).distinct()
+    max_seats={}
+    seats_alloted = {}
+    present_priority = {}
+    next_priority = {}
+    total_seats = 0
+    for course in unique_course :
+        max_seats[course] = Course.objects.get(id=course).max_seats
+        total_seats+=max_seats[course]
+        seats_alloted[course] = 0
+        present_priority[course] = []
+        next_priority[course] = []
+
+    priority_1 = InitialRegistration.objects.filter(Q(semester_id__semester_no = sem) & Q( course_slot_id__name = course_slot ) & Q(student_id__batch = batch) & Q(priority=1))
+    rem=len(priority_1)
+    if rem > total_seats :
+        return -1
+
+    for p in priority_1 :
+        present_priority[p.course_id.id].append([p.student_id.id.id,p.course_slot_id.id])   
+    with transaction.atomic() :
+        p_priority = 1
+        while rem > 0 :
+            for course in present_priority :
+                while(len(present_priority[course])) :
+                    random_student_selected = random.choice(present_priority[course])
+
+                    present_priority[course].remove(random_student_selected)
+
+                    if seats_alloted[course] < max_seats[course] :
+                        stud = Student.objects.get(id__id = random_student_selected[0])
+                        curriculum_object = Student.objects.get(id__id = random_student_selected[0]).batch_id.curriculum
+                        course_object = Course.objects.get(id=course)
+                        course_slot_object = CourseSlot.objects.get(id = random_student_selected[1])
+                        semester_object = Semester.objects.get(Q(semester_no = sem) & Q(curriculum = curriculum_object))
+                        FinalRegistration.objects.create(
+                            student_id = stud,
+                            verified=False,
+                            semester_id = semester_object,
+                            course_id = course_object,
+                            course_slot_id = course_slot_object
+                        )
+                        seats_alloted[course] += 1
+                        rem-=1
+                    else :
+                        next = InitialRegistration.objects.get(Q(student_id__id__id = random_student_selected[0]) & Q( course_slot_id__name = course_slot ) & Q(semester_id__semester_no = sem) & Q(student_id__batch = batch) & Q(priority=p_priority+1))
+                        next_priority[next.course_id.id].append([next.student_id.id.id,next.course_slot_id.id])
+            p_priority+=1
+            present_priority = next_priority
+            next_priority = {course : [] for course in unique_course}
+
+    return 1
+
+@transaction.atomic
+def allocate(request) :
+    batch = request.POST.get('batch')
+    sem = request.POST.get('sem')
+    year = request.POST.get('year')
+    unique_course_slot = InitialRegistration.objects.filter(Q(semester_id__semester_no = sem) & Q(student_id__batch = batch)).values('course_slot_id', 'registration_type').distinct()
+    unique_course_name = []
+    try: 
+        with transaction.atomic() :
+                for entry in unique_course_slot :
+                    course_slot_object = CourseSlot.objects.get(id=entry['course_slot_id'])
+                    print(course_slot_object)
+                    if course_slot_object.type != "Open Elective":
+                        # Fetch students registered in this course slot
+                        students = InitialRegistration.objects.filter(
+                            Q(semester_id__semester_no=sem) &
+                            Q(course_slot_id=course_slot_object) &
+                            Q(student_id__batch=batch)
+                        ).values_list('student_id', flat=True)
+
+                        # Allocate each student directly to FinalRegistration
+                        for student_id in students:
+                            student = Student.objects.get(id=student_id)
+                            semester = Semester.objects.get(semester_no=sem, curriculum=student.batch_id.curriculum)
+                            print(semester.id)
+                            # course = Course.objects.get(id=course_slot_object.courses.id)
+                            course_id = course_slot_object.courses.values_list('id', flat=True).first()
+                            # Retrieve the Course instance
+                            course = Course.objects.get(id=course_id)
+
+                            # Insert directly into FinalRegistration
+                            FinalRegistration.objects.create(
+                                student_id=student,
+                                verified=False,
+                                semester_id=semester,
+                                course_id=course,
+                                course_slot_id=course_slot_object,
+                                registration_type=entry['registration_type']
+                            )
+
+                        unique_course_name.append(course_slot_object.name)
+                    elif course_slot_object.type == "Open Elective": # Runs only for open elective course slots
+                        if course_slot_object.name not in unique_course_name:
+                            stat = random_algo(batch,sem,year,course_slot_object.name)
+                            unique_course_name.append(course_slot_object.name)
+                            if(stat == -1) :
+                                print(course_slot_object.name)
+                                raise Exception("seats not enough for course_slot"+str(course_slot_object.name))
+
+        return JsonResponse({'status': 1 , 'message' : "course allocation successful"})
+    except:
+        return JsonResponse({'status': -1 , 'message' : "seats not enough for some course_slot"})
+
+def view_alloted_course(request) : 
+    batch = request.POST.get('batch')
+    sem = request.POST.get('sem')
+    verified = request.POST.get('year')
+    course = request.POST.get('course')
+
+    registrations = FinalRegistration.objects.filter(Q(student_id__batch = batch) &  Q(semester_id__semester_no = sem) & Q(course_id__code = course))
+    return_list = []
+    for registration in registrations:
+        obj = {
+            'student':registration.student_id.id.id
+        }
+        return_list.append(obj)
+    return JsonResponse({'status':1 , 'student_list':return_list })

FusionIIIT/applications/academic_information/views.py

@@ -16,12 +16,13 @@
 from django.views.decorators.csrf import csrf_exempt
 from django.template.loader import render_to_string
 from django.contrib.auth.decorators import login_required
+from django.contrib import messages
 
-from applications.academic_procedures.models import MinimumCredits, Register, InitialRegistration, course_registration, AssistantshipClaim,Assistantship_status
+from applications.academic_procedures.models import MinimumCredits, Register, InitialRegistration, course_registration, AssistantshipClaim,Assistantship_status,FinalRegistration, StudentRegistrationChecks
 from applications.globals.models import (Designation, ExtraInfo,
                                          HoldsDesignation, DepartmentInfo)
 
-from .forms import AcademicTimetableForm, ExamTimetableForm, MinuteForm
+from .forms import AcademicTimetableForm, ExamTimetableForm, MinuteForm, PreRegistrationSearchForm
 from .models import (Calendar, Course, Exam_timetable, Grades, Curriculum_Instructor,Constants,
                      Meeting, Student, Student_attendance, Timetable,Curriculum)
 from applications.programme_curriculum.models import (CourseSlot, Course as Courses, Batch, Semester, Programme, Discipline)                     
@@ -31,6 +32,7 @@
 from applications.academic_procedures.views import acad_proced_global_context , get_sem_courses
 from applications.programme_curriculum.models import Batch
 from django.db.models import Q
+from .utils import check_for_registration_complete,allocate,view_alloted_course
 
 
 @login_required
@@ -128,6 +130,7 @@ def get_context(request):
         assistant_flag =""
         hod_flag = ""
         account_flag = ""
+        PreRegistrationsrchform = PreRegistrationSearchForm()
 
         for obj in assis_stat:
             assistant_flag = obj.student_status
@@ -177,6 +180,7 @@ def get_context(request):
         'hod_flag' : hod_flag,
         'account_flag' : account_flag,
         'notifications': notifs,
+        'preregistrationsrchform': PreRegistrationsrchform,
     }
 
     return context
@@ -214,8 +218,50 @@ def homepage(request):
     """
     if user_check(request):
         return HttpResponseRedirect('/academic-procedures/')
-
+    
     context = get_context(request)
+
+    if request.method == "POST":
+        if 'check_allocation' in request.POST : 
+            return  check_for_registration_complete(request)
+        if 'start_allocation' in request.POST :
+            return allocate(request)
+        if 'view_allocation' in request.POST :
+            return view_alloted_course(request)
+        if 'search_preregistration' in request.POST or 'delete_preregistration' in request.POST:
+            form = PreRegistrationSearchForm(request.POST)
+            if form.is_valid():
+                roll_no = form.cleaned_data['roll_no'].upper()
+                semester_no = form.cleaned_data['semester_no']
+                print(roll_no, semester_no)
+
+                # Fetch student object by roll number
+                # student = get_object_or_404(Student, id=roll_no)
+
+                # Fetch semester by semester number
+                # semester = get_object_or_404(Semester, semester_no=semester_no)
+                # print(f"Student -> {student}")
+
+                # Search for all initial registrations and student registration check
+                initial_registrations = InitialRegistration.objects.filter(
+                    student_id_id=roll_no, semester_id__semester_no=semester_no
+                )
+                student_registration_check = StudentRegistrationChecks.objects.filter(
+                    student_id_id=roll_no, semester_id__semester_no=semester_no
+                ).first()
+                if ('delete_preregistration' in request.POST):
+                    print(initial_registrations, student_registration_check)
+                    try:
+                        initial_registrations.delete()
+                        student_registration_check.delete()
+                        messages.success(request, "Student's pre registration data successfully deleted.")
+                    except:
+                        messages.error(request, "An error occured while deleting.")
+                    context['delete_preregistration'] = True
+                else :
+                    context['initial_registrations'] = initial_registrations
+                    context['student_registration_check'] = student_registration_check
+                    context['delete_preregistration'] = True
 
     return render(request, "ais/ais.html", context)
 
@@ -1141,7 +1187,52 @@ def generate_preregistration_report(request):
         st = 'attachment; filename = ' + batch.name + batch.discipline.acronym + str(batch.year) + '-preresgistration.xlsx'
         response['Content-Disposition'] = st
         return response
+
+@login_required
+def get_excel(request):
+    batch = request.POST.get('batch-check-view')
+    sem = request.POST.get('semester-check-view')
+    year = request.POST.get('year-check-view')
+    course = request.POST.get('Course-check-view')
+    registrations = FinalRegistration.objects.filter(Q(student_id__batch = batch) & Q(semester_id__semester_no = sem) & Q(course_id__code = course))
+    return_list = []
+    for registration in registrations:
+            return_list.append(registration.student_id.id.id)
+
+    return_list.sort()
+    output = BytesIO()
 
+    book = Workbook(output,{'in_memory':True})
+    title = book.add_format({'bold': True,
+                                    'font_size': 22,
+                                    'align': 'center',
+                                    'valign': 'vcenter'})
+    subtitle = book.add_format({'bold': True,
+                                    'font_size': 15,
+                                    'align': 'center',
+                                    'valign': 'vcenter'})
+    normaltext = book.add_format({'bold': False,
+                                    'font_size': 15,
+                                    'align': 'center',
+                                    'valign': 'vcenter'})
+    sheet = book.add_worksheet()
+    sheet.set_default_row(25)
+    sheet.write_string('A1','Student Roll no',subtitle)
+    sheet.write_string('B1','Student name',subtitle)
+    k=2
+    for no in return_list :
+        student= User.objects.get(username=no)
+        sheet.write_string('A'+str(k),no,normaltext)
+        sheet.write_string('B'+str(k),student.first_name+student.last_name,normaltext)
+        k+=1
+
+    book.close()
+    output.seek(0)
+
+    response = HttpResponse(output.read(),content_type = 'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet')
+    response['Content-Disposition'] = 'attachment; filename='+ course +'_student_list.xlsx'
+    response['Content-Transfer-Encoding'] = 'binary'
+    return response
 
 @login_required
 def add_new_profile (request):

FusionIIIT/applications/academic_procedures/migrations/0002_initialregistration_registration_type.py

@@ -0,0 +1,18 @@
+# Generated by Django 3.1.5 on 2024-11-16 23:49
+
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ('academic_procedures', '0001_initial'),
+    ]
+
+    operations = [
+        migrations.AddField(
+            model_name='initialregistration',
+            name='registration_type',
+            field=models.CharField(choices=[('Audit', 'Audit'), ('Improvement', 'Improvement'), ('Backlog', 'Backlog'), ('Regular', 'Regular')], default='Regular', max_length=20),
+        ),
+    ]

FusionIIIT/applications/academic_procedures/migrations/0003_finalregistration_registration_type.py

@@ -0,0 +1,18 @@
+# Generated by Django 3.1.5 on 2024-11-17 00:34
+
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ('academic_procedures', '0002_initialregistration_registration_type'),
+    ]
+
+    operations = [
+        migrations.AddField(
+            model_name='finalregistration',
+            name='registration_type',
+            field=models.CharField(choices=[('Audit', 'Audit'), ('Improvement', 'Improvement'), ('Backlog', 'Backlog'), ('Regular', 'Regular')], default='Regular', max_length=20),
+        ),
+    ]