feat: added scripts

scripts/create_faculty.py

@@ -0,0 +1,33 @@
+import datetime
+from shell.models import *
+from pseudoc.constants import CATEGORIES, DESIGNATION_DICT, DEPTS, CENTRES
+def create_faculty(data, person_object):
+    """
+    Function to create faculty for a person
+    :param data: data from ACAD API
+    :param person_object: the person whose faculty role to define
+    :return: faculty instance created
+    """
+
+    try:
+        content_object = Department.objects.get(
+                code=DEPTS[data['DepartmentAlphaCode'].lower()]
+            )
+    except KeyError:
+        content_object = Centre.objects.get(
+                 code=CENTRES[data['DepartmentAlphaCode'].lower()] 
+            )
+
+    faculty = FacultyMember.objects.get_or_create(
+        employee_id=int(data['EmployeeNo']),
+        defaults={
+            'content_object': content_object,
+            'start_date': datetime.datetime.now(),
+            'person': person_object,
+            'designation': DESIGNATION_DICT.get(
+                data['Designation'].lower().strip()
+            ),
+        }
+    )
+
+    return faculty

scripts/create_faculty_pseudoc_framework.py

@@ -0,0 +1,31 @@
+from scripts.create_user import create_user
+from scripts.create_faculty import create_faculty
+from scripts.populate_details import populate_details
+from scripts.make_request import make_request
+def create_faculty_pseudoc_framework(data:dict):
+    employee_id = data.get('employee_id', None)
+
+    if employee_id is None:
+        return "Enter a valid employee id" , 400
+
+    data_acad = make_request(employee_id, True)
+
+    if data_acad is None:
+        return "Data on ACAD profile doesn't exist for this user", 400
+
+    user, person = create_user(employee_id, data_acad)
+
+    try:
+        if 'Contract' in data_acad['Designation']:
+            data_acad['Designation'] = 'Assistant Professor (contract)'
+        elif 'Assistant Professor' in data_acad['Designation']:
+            data_acad['Designation'] = 'Assistant Professor'
+        elif 'Visiting Faculty' in data_acad['Designation']:
+            data_acad['Designation'] = 'Visiting Professor'
+        faculty = create_faculty(data_acad, person)
+    except:
+        return "Error creating faculty", 417
+
+    populate_details(person, data_acad)
+
+    return "Successfully created Faculty", 200

scripts/create_new_student.py

@@ -0,0 +1,40 @@
+import datetime
+from registration.models.student import NewStudent
+
+from core.kernel.models import *
+
+
+def create_new_student(data, person_object):
+    """
+    Function to create student for a person
+    :param data: data from ACAD API
+    :param person_object: the person whose student role to be defined
+    :return: student instance created
+    """
+    sem_id = str(data['SemesterID'])
+    try:
+        student = NewStudent(
+            start_date=datetime.datetime.now(),
+            person=person_object,
+            enrolment_number=int(data['EnrollmentNo']),
+            branch=Branch.objects.get(code=data['ProgramID']),
+            current_year=int(sem_id[1]),
+            current_semester=(int(sem_id[1]) - 1) * 2 + int(
+                sem_id[2]) + 1
+        )
+    except:
+        return None
+    try:
+        father = person_object.parents.create()
+        father.contact_information.create()
+        father.save()
+        mother = person_object.parents.create()
+        mother.contact_information.create()
+        mother.save()
+        person_object.save()
+    except:
+        pass
+    student.save()
+
+    return student
+

scripts/create_staff_pseudoc_framework.py

@@ -0,0 +1,12 @@
+
+def create_staff_pseudoc_framework(data:dict):
+    errors_uname = create()
+
+    if len(errors_uname) == 0:
+        return "Succesfully created all staff", 200
+    unames = ''
+
+    for uname in errors_uname:
+        unames += f'{uname} '
+    return f'Error creating following employees {unames}', 417 
+

scripts/create_student.py

@@ -0,0 +1,41 @@
+import datetime
+from core.kernel.models import *
+from scripts.get_semester_from_id import get_semester_from_id
+
+def create_student(data, person_object):
+    """
+    Function to create student for a person
+    :param data: data from ACAD API
+    :param person_object: the person whose student role to be defined
+    :return: student instance created
+    """
+    sem_id = str(data['SemesterID'])
+
+    try:
+        student = Student.objects.get(person=person_object)
+    except:
+        student = Student(
+            start_date=datetime.datetime.now(),
+            person=person_object,
+            enrolment_number=int(data['EnrollmentNo']),
+            branch=Branch.objects.get(code=data['ProgramID']),
+            current_semester=get_semester_from_id(sem_id)
+        )
+        student.save()
+
+        try:
+            local_guardian = person_object.local_guardians.create()
+            local_guardian.contact_information.create()
+            father = Person.objects.create(
+                full_name=data['Fathersname'].title()
+            )
+            mother = Person.objects.create(
+                full_name=data['MotherName'].title(),
+            )
+            person_object.parents.add(father)
+            person_object.parents.add(mother)
+            person_object.save()
+        except:
+            pass
+
+    return student

scripts/create_student_pseudoc_framework.py

@@ -0,0 +1,36 @@
+from scripts.create_user import create_user
+from scripts.create_student import create_student
+from scripts.populate_details import populate_details
+from scripts.make_request import make_request
+
+def create_student_pseudoc_framework(data:dict):
+    enrolment_number = data.get('enrolment_number', None)
+
+    if enrolment_number is None:
+        return "Enter a valid enrolment number" , 400
+
+    data_acad = make_request(enrolment_number, False)
+
+    if data_acad is None:
+        return "Data on ACAD profile doesn't exist for this user", 400
+
+
+    user, person = create_user(enrolment_number, data_acad)
+
+    try:
+        student = create_student(data_acad, person)
+    except:
+        return "Error creating student", 417
+
+    populate_details(person, data_acad)
+    contact = person.contact_information.get()
+
+    if contact.institute_webmail_address is None:
+        contact.institute_webmail_address = data_acad['IITREmailID']
+        print(enrolment_number)
+        contact.save()
+
+    print(f'{person} ::: {person.contact_information.get()}')
+
+    return "Successfully created Student", 200
+

scripts/create_user.py

@@ -0,0 +1,31 @@
+
+from django.db import IntegrityError
+
+from core.kernel.models import *
+from formula_one.models import *
+from shell.models import *
+from core.base_auth.models import User
+
+def create_user(username, acad_data):
+    """
+    Function to create a user and person instancec for omniport
+    :param username: Username of the user to be created
+    :param acad_data: Data from the acad API, which we use to create user
+    :return: user and person instance created
+    """
+    user, _ = User.objects.get_or_create(
+        username=username,
+    )
+    try:
+        person, person_created = Person.objects.get_or_create(
+            user=user,
+            full_name=acad_data['Name'].title(),
+        )
+    except IntegrityError:
+        person = Person.objects.get(
+            user=user
+        )
+        person.full_name = acad_data['Name'].title()
+        person.save()
+
+    return user, person

scripts/get_semester_from_id.py

@@ -0,0 +1,20 @@
+
+mba_map = {
+    '310': 1,
+    '320': 2,
+    '331': 3,
+    '341': 4,
+    '350': 5,
+    '360': 6,
+    '371': 7,
+    '381': 8
+}
+mba_sem_id = [int(id) for id in mba_map.keys()]
+
+def get_semester_from_id(semester_id):
+    semester_id = int(semester_id)
+    if semester_id in mba_sem_id:
+        return mba_map[str(semester_id)]
+    else:
+        semester_id = str(semester_id)
+        return (int(semester_id[1])-1)*2+int(semester_id[2])+1

scripts/make_request.py

@@ -0,0 +1,27 @@
+import requests
+from pseudoc.secrets import ACAD_URL_FACULTY, ACAD_URL_STUDENT, HEADER, NEW_ACAD_URL_STUDENT, NEW_ACAD_URL_FACULTY
+def make_request(username, is_faculty=False):
+    """
+    :param username: username for whom data to be fetched
+    :param is_faculty: True if user is a faculty
+    :return: dat on success, None otherwise
+    """
+    try:
+        r = requests.get(
+            url=f'{NEW_ACAD_URL_STUDENT}{username}' if not is_faculty
+                else f'{NEW_ACAD_URL_FACULTY}{username}',
+            headers=HEADER,
+        )
+        data = r.json()
+        if isinstance(data, list):
+            data = data[0] if len(data)==1 else None
+        if not (data or is_faculty):
+            r = requests.get(
+                url=f'{ACAD_URL_STUDENT}{username}' if not is_faculty
+                    else f'{ACAD_URL_FACULTY}{username}',
+                headers=HEADER,
+            )
+            data = r.json()
+        return data
+    except requests.ConnectionError:
+        return None

scripts/populate_contact_info.py

@@ -0,0 +1,42 @@
+
+from django.db import IntegrityError
+
+from core.base_auth.managers.get_user import get_user
+
+def populate_contact_info(contact_information, details):
+    """
+    Function to populate the contact info of a person based on ACAD API data
+    :param contact_information: location information instance
+    :param details: data from ACAD API
+    :return: True if successful, False otherwise
+    """
+    try:
+        contact_information.primary_phone_number = details.get(
+            'Mobileno', None
+        )
+        contact_information.secondary_phone_number = details.get(
+            'ContactNo', None
+        )
+        if contact_information.secondary_phone_number == '':
+            contact_information.secondary_phone_number = None
+        contact_information.email_address = details.get('EmailID', None)
+
+        institute_email_id = details['IITREmailID']
+        if not contact_information.institute_webmail_address or contact_information.institute_webmail_address != institute_email_id:
+            try:
+                contact_information.institute_webmail_address = institute_email_id
+            except IntegrityError:
+                person2 = get_user(institute_email_id).person
+                contact2 = person2.contact_information.get()
+                contact2.institute_webmail_address = None
+                contact2.save()
+
+                contact_information.institute_webmail_address = institute_email_id
+            except Exception as e:
+                return False
+
+        contact_information.save()
+        return True
+    except:
+        return False
+