200010030
/
cdc-placement-website-backend
mirror of https://github.com/CDC-IITDH/cdc-placement-website-backend
1
0
Fork 0
Code Issues Projects Releases Wiki Activity

Merge pull request #178 from uttamthummala/Internship-Update 

Internship update
This commit is contained in:
karthik mv 2023-10-19 04:33:30 +05:30 committed by GitHub
parent 7fc18bb2fb 7615713213
commit f4a55b1d60
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
31 changed files with 3552 additions and 511 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

64
.github/workflows/django.yml vendored Normal file
View File

@ -0,0 +1,64 @@
name: Django CI
on:
push:
branches: [ "main" ]
pull_request:
branches: [ "main" ]
env:
HOSTING_URL: "http://localhost:8000/"
DEBUG: True
EMAIL: karthik.murakonda14@gmail.com
EMAIL_PASSWORD: 1234567890
EMAIL_VERIFICATION_SECRET_KEY: "b'<\xa3\xaf&d6\xa9sf\x19$\x96\xb7\x90\x8b\x88\x84\x0e\x191\xde,M\x90\x17(\xf7\nG\x13\x8d$\x9f&\xb0\xcd\xa4\xaf\xa9\x1b\x15\x02B\x8a\xaf\xff\x0c\x1e\xd5\xb3\x06\xb8\xa6\x9bQ\xa0TR\xe8\x98\x9ae\xe0n}\xcc/[\xdaFz\x18\xfeX\xaf\xbd\xd0\x88\xeal\xe3\xd2\xe3\xb8\x8c\x199{\xf3<\xb0\xc5\xd0\xe7*Rv\xda\xbb \x1d\x85~\xff%>\x1e\xb8\xa7\xbf\xbc\xb2\x06\x86X\xc3\x9f\x13<\x9fd\xea\xb5\x01\xa4\x7f\xa0\x1b\x8bO\x01h\xe8\xfd\x1f\xfe\xba\xbeg\\\xc2\xcb\xc3\xd1~\xff\xd5/9d\xa8\xa7x{\x16\xdb\\\xbb\x08\rI\xcd\x9e7\x8c~\x0f\x1d\x81rXZD\xf0\xf7\x87K\x8f\xfb,\xf4\xf0\xa5\x9e\xde^\xca\xae\x80|9b\x9b\xaaE\xba\xfb\xdf\x80\xb1\x99\x83e[\xf8\xce&Rq\x99\xdb}\xeeO\xd5\x18\x8d\x0bv\xe7\xab\xf9\xb9{\xb5u\xce\xcf\x90\xa6HE\xc5\x92p\x00\x158\xdf'"
DB_NAME: cdc
DB_USER: postgres
DB_PASSWORD: postgres
DB_HOST: localhost
DB_PORT: 5432
RECAPTCHA_SECRET_KEY: 6LfpadYhAAAAAJUIJQ_JJqkqq3arvalwkVCgW3nG
GOOGLE_OAUTH_CLIENT_ID: 628308091838-nvfn455vabbq7j0odd797sls8itpplmr.apps.googleusercontent.com
SECRET_KEY: 9%2e!&f6(ib^690y48z)&w6fczhwukzzp@3y*^*7u+7%4s-mie
GOOGLE_OAUTH_CLIENT_SECRET: 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
REFRESH_TOKEN: 1//0gCf5fxAgSqNcCgYIARAAGBASNwF-L9IrIWxWwqmboeJkEzVn0sqxbaeyWXODE5s24V7pSdiAzFM2cxOUC9XT_xp7t_60o3JMfOg
EMAIL_ID: 200010030@iitdh.ac.in
ROLL_NO: 200010030
jobs:
build:
runs-on: ubuntu-latest
services:
postgres:
image: postgres
env:
POSTGRES_USER: postgres
POSTGRES_PASSWORD: postgres
POSTGRES_DB: cdc
ports:
- 5432:5432
options: --health-cmd pg_isready --health-interval 10s --health-timeout 5s --health-retries 5
strategy:
max-parallel: 4
matrix:
python-version: [3.9]
steps:
- uses: actions/checkout@v3
- name: Set up Python ${{ matrix.python-version }}
uses: actions/setup-python@v3
with:
python-version: ${{ matrix.python-version }}
- name: Install Dependencies
run: |
python -m pip install --upgrade pip
pip install -r requirements.txt
- name: Run Tests
run: |
cd CDC_Backend
python manage.py collectstatic
python manage.py makemigrations
python manage.py makemigrations APIs
python manage.py test

1
.gitignore vendored
View File

@ -129,7 +129,6 @@ dmypy.json
/venv/
/.github/
./CDC_Backend/static
./CDC_Backend/Storage
/CDC_Backend/CDC_Backend/__pycache__/

29
CDC_Backend/APIs/admin.py
View File

@ -138,6 +138,13 @@ class PlacementApplicationResources(resources.ModelResource):
class PlacementAdmin(ExportMixin, SimpleHistoryAdmin):
resource_class = PlacementApplicationResources
class InternshipApplicationResources(resources.ModelResource):
class Meta:
model = InternshipApplication
exclude = ('id', 'changed_by')
class InternshipApplicationAdmin(ExportMixin, SimpleHistoryAdmin):
resource_class = InternshipApplicationResources
@admin.register(PlacementApplication)
class PlacementApplication(PlacementAdmin):
@ -151,7 +158,18 @@ class PlacementApplication(PlacementAdmin):
def Student(self, obj):
return model_admin_url(obj.student)
@admin.register(InternshipApplication)
class InternshipApplication(InternshipApplicationAdmin):
list_display = ('id', 'Internship', 'Student', 'selected')
search_fields = ('id',)
ordering = ('id',)
list_filter = ('selected',)
def Internship(self, obj):
return model_admin_url(obj.internship)
def Student(self, obj):
return model_admin_url(obj.student)
class PrePlacementResources(resources.ModelResource):
class Meta:
@ -178,7 +196,7 @@ class InternshipResources(resources.ModelResource):
class Meta:
model = Internship
exclude = ('id', 'changed_by', 'is_company_details_pdf', 'is_description_pdf',
'is_compensation_details_pdf', 'is_selection_procedure_details_pdf')
'is_stipend_details_pdf', 'is_selection_procedure_details_pdf')
class InternAdmin(ExportMixin, SimpleHistoryAdmin):
@ -199,3 +217,12 @@ class Placement(InternAdmin):
search_fields = (COMPANY_NAME, CONTACT_PERSON_NAME)
ordering = ('updated_at', COMPANY_NAME, CONTACT_PERSON_NAME, 'stipend')
@admin.register(Issues)
class Issues(admin.ModelAdmin):
list_display = ('id', 'title', 'description')
search_fields = ('id', 'title', 'description')
ordering = ('id', 'title', 'description')
# list_filter = ('status',)
def Student(self, obj):
return model_admin_url(obj.student)

203
CDC_Backend/APIs/adminViews.py
View File

@ -12,8 +12,14 @@ from .utils import *
def markStatus(request, id, email, user_type):
try:
data = request.data
# Getting all application from db for this opening
applications = PlacementApplication.objects.filter(placement_id=data[OPENING_ID])
if OPENING_TYPE in data:
opening_type= data[OPENING_TYPE] #not to break the code
else:
opening_type= "Placement"
if opening_type == "Internship":
applications = InternshipApplication.objects.filter(internship_id=data[OPENING_ID])
else:
applications = PlacementApplication.objects.filter(placement_id=data[OPENING_ID])
for i in data[STUDENT_LIST]:
application = applications.filter(student__roll_no=i[STUDENT_ID]) # Filtering student's application
if len(application) > 0:
@ -27,14 +33,23 @@ def markStatus(request, id, email, user_type):
raise ValueError("Student already selected")
email = str(application.student.roll_no) + "@iitdh.ac.in" # Only allowing for IITDh emails
subject = STUDENT_APPLICATION_STATUS_TEMPLATE_SUBJECT.format(
company_name=application.placement.company_name,
id=application.id)
data = {
"company_name": application.placement.company_name,
"designation": application.placement.designation,
"student_name": application.student.name
}
if opening_type == "Internship":
subject = STUDENT_APPLICATION_STATUS_TEMPLATE_SUBJECT.format(
company_name=application.internship.company_name,id=application.id)
data = {
"company_name": application.internship.company_name,
"designation": application.internship.designation,
"student_name": application.student.name
}
else:
subject = STUDENT_APPLICATION_STATUS_TEMPLATE_SUBJECT.format(
company_name=application.placement.company_name,
id=application.id)
data = {
"company_name": application.placement.company_name,
"designation": application.placement.designation,
"student_name": application.student.name
}
if application.selected: # Sending corresponding email to students
sendEmail(email, subject, data, STUDENT_APPLICATION_STATUS_SELECTED_TEMPLATE)
else:
@ -42,7 +57,7 @@ def markStatus(request, id, email, user_type):
application.chaged_by = get_object_or_404(User, id=id)
application.save()
else:
raise ValueError("Student - " + i[STUDENT_ID] + " didn't apply for this opening")
raise ValueError("Student - " + str(i[STUDENT_ID]) + " didn't apply for this opening")
return Response({'action': "Mark Status", 'message': "Marked Status"},
status=status.HTTP_200_OK)
@ -64,13 +79,22 @@ def getDashboard(request, id, email, user_type):
previous = placements.exclude(deadline_datetime__gt=timezone.now()).filter(
offer_accepted=True, email_verified=True)
new = placements.filter(offer_accepted__isnull=True, email_verified=True)
internships=Internship.objects.all().order_by('-created_at')
ongoing_internships = internships.filter(deadline_datetime__gt=timezone.now(), offer_accepted=True, email_verified=True)
previous_internships = internships.exclude(deadline_datetime__gt=timezone.now()).filter(
offer_accepted=True, email_verified=True)
new_internships = internships.filter(offer_accepted__isnull=True, email_verified=True)
ongoing = PlacementSerializerForAdmin(ongoing, many=True).data
previous = PlacementSerializerForAdmin(previous, many=True).data
new = PlacementSerializerForAdmin(new, many=True).data
ongoing_internships = InternshipSerializerForAdmin(ongoing_internships, many=True).data
previous_internships = InternshipSerializerForAdmin(previous_internships, many=True).data
new_internships = InternshipSerializerForAdmin(new_internships, many=True).data
return Response(
{'action': "Get Dashboard - Admin", 'message': "Data Found", "ongoing": ongoing, "previous": previous,
"new": new},
"new": new, "ongoing_internships": ongoing_internships, "previous_internships": previous_internships,
"new_internships": new_internships},
status=status.HTTP_200_OK)
except Http404:
return Response({'action': "Get Dashboard - Admin", 'message': 'Student Not Found'},
@ -87,7 +111,15 @@ def getDashboard(request, id, email, user_type):
def updateDeadline(request, id, email, user_type):
try:
data = request.data
opening = get_object_or_404(Placement, pk=data[OPENING_ID])
if OPENING_TYPE in data:
opening_type= data[OPENING_TYPE]
else:
opening_type= "Placement"
if opening_type == "Internship":
opening = get_object_or_404(Internship, pk=data[OPENING_ID])
else:
opening = get_object_or_404(Placement, pk=data[OPENING_ID])
# Updating deadline date with correct format in datetime field
opening.deadline_datetime = datetime.datetime.strptime(data[DEADLINE_DATETIME], '%Y-%m-%d %H:%M:%S %z')
opening.changed_by = get_object_or_404(User, id=id)
@ -110,13 +142,25 @@ def updateOfferAccepted(request, id, email, user_type):
try:
data = request.data
offer_accepted = data[OFFER_ACCEPTED]
opening = get_object_or_404(Placement, pk=data[OPENING_ID])
if OPENING_TYPE in data:
opening_type= data[OPENING_TYPE]
else:
opening_type= "Placement"
if DEADLINE_DATETIME in data:
deadline_datetime = datetime.datetime.strptime(data[DEADLINE_DATETIME], '%Y-%m-%d %H:%M:%S %z')
else:
deadline_datetime = timezone.now().replace(hour=0, minute=0, second=0, microsecond=0) + datetime.timedelta(days=2)
if opening_type == "Internship":
opening = get_object_or_404(Internship, pk=data[OPENING_ID])
else:
opening = get_object_or_404(Placement, pk=data[OPENING_ID])
if opening.offer_accepted is None:
opening.offer_accepted = offer_accepted == "true"
opening.deadline_datetime = deadline_datetime
opening.changed_by = get_object_or_404(User, id=id)
opening.save()
if opening.offer_accepted:
send_opening_notifications(opening.id)
send_opening_notifications(opening.id,opening_type)
else:
raise ValueError("Offer Status already updated")
@ -140,7 +184,14 @@ def updateOfferAccepted(request, id, email, user_type):
def updateEmailVerified(request, id, email, user_type):
try:
data = request.data
opening = get_object_or_404(Placement, pk=data[OPENING_ID])
if OPENING_TYPE in data:
opening_type= data[OPENING_TYPE]
else:
opening_type= "Placement"
if opening_type == "Internship":
opening = get_object_or_404(Internship, pk=data[OPENING_ID])
else:
opening = get_object_or_404(Placement, pk=data[OPENING_ID])
opening.email_verified = True if data[EMAIL_VERIFIED] == "true" else False
opening.changed_by = get_object_or_404(User, id=id)
opening.save()
@ -161,7 +212,14 @@ def updateEmailVerified(request, id, email, user_type):
def deleteAdditionalInfo(request, id, email, user_type):
try:
data = request.data
opening = get_object_or_404(Placement, pk=data[OPENING_ID])
if OPENING_TYPE in data:
opening_type= data[OPENING_TYPE]
else:
opening_type= "Placement"
if opening_type == "Internship":
opening = get_object_or_404(Internship, pk=data[OPENING_ID])
else:
opening = get_object_or_404(Placement, pk=data[OPENING_ID])
if data[FIELD] in opening.additional_info:
opening.additional_info.remove(data[FIELD])
opening.changed_by = get_object_or_404(User, id=id)
@ -188,7 +246,14 @@ def deleteAdditionalInfo(request, id, email, user_type):
def addAdditionalInfo(request, id, email, user_type):
try:
data = request.data
opening = get_object_or_404(Placement, pk=data[OPENING_ID])
if OPENING_TYPE in data:
opening_type= data[OPENING_TYPE]
else:
opening_type= "Placement"
if opening_type == "Internship":
opening = get_object_or_404(Internship, pk=data[OPENING_ID])
else:
opening = get_object_or_404(Placement, pk=data[OPENING_ID])
if data[FIELD] not in opening.additional_info:
opening.additional_info.append(data[FIELD])
opening.save()
@ -215,11 +280,20 @@ def addAdditionalInfo(request, id, email, user_type):
def getApplications(request, id, email, user_type):
try:
data = request.GET
opening = get_object_or_404(Placement, pk=data[OPENING_ID])
applications = PlacementApplication.objects.filter(placement=opening)
serializer = PlacementApplicationSerializerForAdmin(applications, many=True)
if OPENING_TYPE in data:
opening_type= data[OPENING_TYPE]
else:
opening_type= "Placement"
if opening_type == "Internship":
opening = get_object_or_404(Internship, pk=data[OPENING_ID])
applications = InternshipApplication.objects.filter(internship=opening)
serializer = InternshipApplicationSerializerForAdmin(applications, many=True)
else:
opening = get_object_or_404(Placement, pk=data[OPENING_ID])
applications = PlacementApplication.objects.filter(placement=opening)
serializer = PlacementApplicationSerializerForAdmin(applications, many=True)
return Response({'action': "Get Applications", 'message': 'Data Found', 'applications': serializer.data},
status=status.HTTP_200_OK)
status=status.HTTP_200_OK)
except Http404:
return Response({'action': "Get Applications", 'message': 'Opening Not Found'},
status=status.HTTP_404_NOT_FOUND)
@ -235,13 +309,24 @@ def getApplications(request, id, email, user_type):
def submitApplication(request, id, email, user_type):
try:
data = request.data
if OPENING_TYPE in data:
opening_type= data[OPENING_TYPE]
else:
opening_type= "Placement"
if opening_type == "Internship":
opening = get_object_or_404(Internship, pk=data[OPENING_ID])
else:
opening = get_object_or_404(Placement, pk=data[OPENING_ID])
student = get_object_or_404(Student, pk=data[STUDENT_ID])
opening = get_object_or_404(Placement, pk=data[OPENING_ID])
# opening = get_object_or_404(Placement, pk=data[OPENING_ID])
student_user = get_object_or_404(User, id=student.id)
if data[APPLICATION_ID] == "":
application = PlacementApplication()
application = PlacementApplication() if opening_type == "Placement" else InternshipApplication()
application.id = generateRandomString()
application.placement = opening
if(opening_type == "Placement"):
application.placement = opening
else:
application.internship = opening
application.student = student
if data[RESUME_FILE_NAME] in student.resumes:
application.resume = data[RESUME_FILE_NAME]
@ -257,7 +342,7 @@ def submitApplication(request, id, email, user_type):
data = {
"name": student.name,
"company_name": opening.company_name,
"application_type": "Placement",
"application_type": "Placement" if opening_type == "Placement" else "Internship",
"additional_info": dict(json.loads(application.additional_info)),
}
subject = STUDENT_APPLICATION_SUBMITTED_TEMPLATE_SUBJECT.format(company_name=opening.company_name)
@ -267,7 +352,10 @@ def submitApplication(request, id, email, user_type):
return Response({'action': "Add Student Application", 'message': "Application added"},
status=status.HTTP_200_OK)
else:
application = get_object_or_404(PlacementApplication, id=data[APPLICATION_ID])
if opening_type == "Internship":
application = get_object_or_404(InternshipApplication, id=data[APPLICATION_ID])
else:
application = get_object_or_404(PlacementApplication, id=data[APPLICATION_ID])
if application:
if data[RESUME_FILE_NAME] in student.resumes:
application.resume = data[RESUME_FILE_NAME]
@ -285,7 +373,7 @@ def submitApplication(request, id, email, user_type):
data = {
"name": student.name,
"company_name": opening.company_name,
"application_type": "Placement",
"application_type": "Placement" if opening_type == "Placement" else "Internship",
"resume": application.resume[16:],
"additional_info_items": dict(json.loads(application.additional_info)),
}
@ -308,29 +396,39 @@ def submitApplication(request, id, email, user_type):
except FileNotFoundError as e:
return Response({'action': "Submit Application", 'message': str(e)},
status=status.HTTP_404_NOT_FOUND)
except AttributeError as e:
return Response({'action': "Submit Application", 'message': str(e)},
status=status.HTTP_400_BAD_REQUEST)
except:
logger.warning("Submit Application: " + str(sys.exc_info()))
return Response({'action': "Submit Application", 'message': "Something Went Wrong"},
status=status.HTTP_400_BAD_REQUEST)
@api_view(['POST'])
@isAuthorized(allowed_users=[ADMIN])
@precheck(required_data=[OPENING_ID])
def generateCSV(request, id, email, user_type):
try:
data = request.data
placement = get_object_or_404(Placement, id=data[OPENING_ID])
applications = PlacementApplication.objects.filter(placement=placement)
if OPENING_TYPE in data:
opening_type= data[OPENING_TYPE]
else:
opening_type= "Placement"
if opening_type == "Internship":
opening = get_object_or_404(Internship, id=data[OPENING_ID])
applications = InternshipApplication.objects.filter(internship=opening)
else:
opening = get_object_or_404(Placement, id=data[OPENING_ID])
applications = PlacementApplication.objects.filter(placement=opening)
filename = generateRandomString()
if not os.path.isdir(STORAGE_DESTINATION_APPLICATION_CSV):
os.mkdir(STORAGE_DESTINATION_APPLICATION_CSV)
os.makedirs(STORAGE_DESTINATION_APPLICATION_CSV, exist_ok=True)
destination_path = STORAGE_DESTINATION_APPLICATION_CSV + filename + ".csv"
f = open(destination_path, 'w')
writer = csv.writer(f)
header_row = APPLICATION_CSV_COL_NAMES.copy()
header_row.extend(placement.additional_info)
header_row.extend(opening.additional_info)
writer.writerow(header_row)
for apl in applications:
row_details = []
@ -343,11 +441,11 @@ def generateCSV(request, id, email, user_type):
row_details.append(apl.student.branch)
row_details.append(apl.student.batch)
row_details.append(apl.student.cpi)
link = LINK_TO_STORAGE_RESUME + urllib.parse.quote(apl.student.id) + "/" + urllib.parse.quote(apl.resume)
link = LINK_TO_STORAGE_RESUME + urllib.parse.quote(str(apl.student.id)) + "/" + urllib.parse.quote(str(apl.resume))
row_details.append(link)
row_details.append(apl.selected)
for i in placement.additional_info:
for i in opening.additional_info:
row_details.append(json.loads(apl.additional_info)[i])
writer.writerow(row_details)
@ -397,6 +495,10 @@ def addPPO(request, id, email, user_type):
def getStudentApplication(request, id, email, user_type):
try:
data = request.data
if OPENING_TYPE in data:
opening_type= data[OPENING_TYPE]
else:
opening_type= "Placement"
student = get_object_or_404(Student, id=data[STUDENT_ID])
student_serializer = StudentSerializer(student)
student_details = {
@ -406,15 +508,29 @@ def getStudentApplication(request, id, email, user_type):
"resume_list": student_serializer.data['resume_list'],
}
# search for the application if there or not
application = PlacementApplication.objects.filter(student=student,
if opening_type == "Internship":
application = InternshipApplication.objects.filter(student=student,
internship=get_object_or_404(Internship,
id=data[OPENING_ID]))
else:
application = PlacementApplication.objects.filter(student=student,
placement=get_object_or_404(Placement, id=data[OPENING_ID]))
if application:
serializer = PlacementApplicationSerializer(application[0])
application_info = {
"id": serializer.data['id'],
"additional_info": serializer.data['additional_info'],
"resume": serializer.data['resume_link'],
}
if opening_type == "Internship":
serializer = InternshipApplicationSerializer(application[0])
application_info = {
"id": serializer.data['id'],
"additional_info": serializer.data['additional_info'],
"resume": serializer.data['resume_link'],
}
else:
serializer = PlacementApplicationSerializer(application[0])
application_info = {
"id": serializer.data['id'],
"additional_info": serializer.data['additional_info'],
"resume": serializer.data['resume_link'],
}
return Response(
{'action': "Get Student Application", 'application_found': "true", "application_info": application_info,
"student_details": student_details}, status=status.HTTP_200_OK)
@ -446,6 +562,7 @@ def getStats(request, id, email, user_type):
"5":0,
"6":0,
"7":0,
"8":0,
"psu":0,
},
"EE": {
@ -466,6 +583,7 @@ def getStats(request, id, email, user_type):
"5":0,
"6":0,
"7":0,
"8":0,
"psu":0,
},
@ -477,6 +595,7 @@ def getStats(request, id, email, user_type):
"5":0,
"6":0,
"7":0,
"8":0,
"psu":0,
},
}

1
CDC_Backend/APIs/companyUrls.py
View File

@ -7,4 +7,5 @@ urlpatterns = [
path('verifyEmail/', companyViews.verifyEmail, name="Verify Email"),
path('getAutoFillJnf/', companyViews.autoFillJnf, name="Auto FIll JNF"),
path('addInternship/',companyViews.addInternship,name="Add Internship"),
path('getAutoFillInf/', companyViews.autoFillInf, name="Auto FIll INF"),
]

31
CDC_Backend/APIs/companyViews.py
View File

@ -321,6 +321,24 @@ def autoFillJnf(request):
return Response({'action': "Get AutoFill", 'message': "Something went wrong"},
status=status.HTTP_400_BAD_REQUEST)
@api_view(['GET'])
@precheck([INTERNSHIP_ID])
def autoFillInf(request):
try:
data = request.GET
internship_id = data.get(INTERNSHIP_ID)
opening = get_object_or_404(Internship, id=internship_id)
serializer = AutofillSerializersInternship(opening)
return Response({'action': "Get AutoFill ", 'message': 'Data Found', 'internship_data': serializer.data},
status=status.HTTP_200_OK)
except Http404:
return Response({'action': "Get AutoFill", 'message': 'Internship Not Found'},
status=status.HTTP_404_NOT_FOUND)
except Exception as e:
traceback_str = traceback.format_exc()
logger.warning("Get AutoFill: " + traceback_str)
return Response({'action': "Get AutoFill", 'message': "Something went wrong"},
status=status.HTTP_400_BAD_REQUEST)
## Internships ##
@ -397,6 +415,14 @@ def addInternship(request):
internship.is_work_from_home = True
else:
internship.is_work_from_home = False
if data[ALLOWED_BATCH] is None or json.loads(data[ALLOWED_BATCH]) == "":
raise ValueError('Allowed Branch cannot be empty')
elif set(json.loads(data[ALLOWED_BATCH])).issubset(BATCHES):
internship.allowed_batch = json.loads(data[ALLOWED_BATCH])
else:
raise ValueError('Allowed Batch must be a subset of ' + str(BATCHES))
if data[ALLOWED_BRANCH] is None or json.loads(data[ALLOWED_BRANCH]) == "":
raise ValueError('Allowed Branch cannot be empty')
elif set(json.loads(data[ALLOWED_BRANCH])).issubset(BRANCHES):
@ -468,6 +494,11 @@ def addInternship(request):
internship.selection_procedure_details_pdf_names = selection_procedure_details_pdf
internship.additional_facilities = data[OTHER_FACILITIES]
#add additional info
# Only Allowing Fourth Year for Placement
internship.academic_requirements = data[OTHER_REQUIREMENTS]

16
CDC_Backend/APIs/constants.py
View File

@ -21,6 +21,12 @@ BRANCHES = [
"CHEMICAL",
"BSMS",
]
BATCHES = [ #change it accordingly
"2023",
"2022",
"2021",
"2020",
]
BATCH_CHOICES = [
["2022", "2022"],
["2021", "2021"],
@ -67,6 +73,10 @@ CDC_REPS_EMAILS = [
"suvamay.jana@iitdh.ac.in",
"ramesh.nayaka@iitdh.ac.in"
]
CDC_REPS_EMAILS_FOR_ISSUE=[ #add reps emails
"cdc.support@iitdh.ac.in",
"cdc@iitdh.ac.in"
]
# To be Configured Properly
CLIENT_ID = os.environ.get('GOOGLE_OAUTH_CLIENT_ID') # Google Login Client ID
@ -201,7 +211,9 @@ APPLICATION_CSV_COL_NAMES = ['Applied At', 'Roll No.', 'Name', 'Email', 'Phone N
'Resume', 'Selected', ]
ISSUE_SUBMITTED_TEMPLATE_SUBJECT = 'CDC - Issue Submitted'
STUDENT_ISSUE_SUBMITTED_TEMPLATE = 'student_issue_submitted.html'
REPS_ISSUE_SUBMITTED_TEMPLATE = 'reps_issue_submitted.html'
# Internships
INTERNSHIP = 'Internship'
INTERNSHIP_ID = 'internship_id'
@ -218,6 +230,8 @@ STIPEND = 'stipend'
FACILITIES = 'facilities'
OTHER_FACILITIES = 'other_facilities'
STIPEND_DETAILS_PDF = 'compensation_details_pdf'
STIPEND_DETAILS_PDF_NAMES = 'stipend_description_pdf_names'
INTERNSHIP_OPENING_URL = "https://cdc.iitdh.ac.in/portal/student/dashboard/internships/{id}" # On frontend, this is the URL to be opened
SEASONS = (
'Summer',

46
CDC_Backend/APIs/models.py
View File

@ -32,6 +32,7 @@ class Student(models.Model):
default=list, blank=True)
cpi = models.DecimalField(decimal_places=2, max_digits=4)
can_apply = models.BooleanField(default=True, verbose_name='Registered')
can_apply_internship = models.BooleanField(default=True, verbose_name='Internship Registered') #added for internship
changed_by = models.ForeignKey(User, blank=True, on_delete=models.RESTRICT, default=None, null=True)
degree = models.CharField(choices=DEGREE_CHOICES, blank=False, max_length=10, default=DEGREE_CHOICES[0][0])
history = HistoricalRecords(user_model=User)
@ -318,6 +319,11 @@ class Internship(models.Model):
size=TOTAL_BRANCHES,
default=list
)
allowed_batch = ArrayField(
models.CharField(max_length=10, choices=BATCH_CHOICES),
size=TOTAL_BATCHES,
default=list
)
sophomore_eligible = models.BooleanField(blank=False, default=False)
rs_eligible = models.BooleanField(blank=False, default=False)
tentative_no_of_offers = models.IntegerField(blank=False, default=None, null=True)
@ -332,6 +338,11 @@ class Internship(models.Model):
default=list,
blank=True
)
additional_info = ArrayField(models.CharField(blank=True, max_length=JNF_TEXTMEDIUM_MAX_CHARACTER_COUNT), size=15,
default=list, blank=True)
offer_accepted = models.BooleanField(blank=False, default=None, null=True)
deadline_datetime = models.DateTimeField(blank=False, verbose_name="Deadline Date", default=two_day_after_today)
additional_facilities = models.CharField(blank=True, max_length=JNF_TEXTAREA_MAX_CHARACTER_COUNT, default=None, null=True)
academic_requirements = models.CharField(blank=True, max_length=JNF_TEXTAREA_MAX_CHARACTER_COUNT, default=None, null=True)
# selection process
@ -388,6 +399,9 @@ class Internship(models.Model):
self.additional_facilities = self.additional_facilities.strip()[:JNF_TEXTAREA_MAX_CHARACTER_COUNT]
if self.academic_requirements is not None:
self.academic_requirements = self.academic_requirements.strip()[:JNF_TEXTAREA_MAX_CHARACTER_COUNT]
if self.additional_info is not None:
self.additional_info = [info.strip()[:JNF_TEXTMEDIUM_MAX_CHARACTER_COUNT] for info in
list(self.additional_info)]
# if self.contact_person_designation is not None:
# self.contact_person_designation = self.contact_person_designation.strip()[:JNF_SMALLTEXT_MAX_CHARACTER_COUNT]
@ -421,6 +435,7 @@ class InternshipApplication(models.Model):
resume = models.CharField(max_length=JNF_TEXT_MAX_CHARACTER_COUNT, blank=False, null=True, default=None)
additional_info = models.JSONField(blank=True, null=True, default=None)
selected = models.BooleanField(null=True, default=None, blank=True)
offer_accepted = models.BooleanField(null=True, default=None, blank=True) # True if offer accepted, False if rejected, None if not yet decided
stipend = models.IntegerField(blank=True, default=None, null=True)
applied_at = models.DateTimeField(blank=False, default=None, null=True)
updated_at = models.DateTimeField(blank=False, default=None, null=True)
@ -464,4 +479,33 @@ class Contributor(models.Model):
image = models.CharField(max_length=JNF_SMALLTEXT_MAX_CHARACTER_COUNT, blank=False, default="", null=True)
def __str__(self):
return self.name
return self.name
class Issues(models.Model):
id = models.AutoField(primary_key=True)
title = models.CharField(max_length=JNF_SMALLTEXT_MAX_CHARACTER_COUNT, blank=False, default="")
description = models.CharField(max_length=200, blank=False, default="")
#opening=(models.ForeignKey(Placement, on_delete=models.CASCADE, blank=False) or models.ForeignKey(Internship, on_delete=models.CASCADE, blank=False))
opening_id=models.CharField(blank=False, max_length=15, default=None, null=True)
opening_type=models.CharField(choices=[('Placement','Placement'),('Internship','Internship')], blank=False, max_length=15, default=PLACEMENT)
#status = models.CharField(max_length=JNF_SMALLTEXT_MAX_CHARACTER_COUNT, blank=False, default="")
student=models.ForeignKey(Student, on_delete=models.CASCADE, blank=False)
created_at = models.DateTimeField(blank=False, default=None, null=True)
updated_at = models.DateTimeField(blank=False, default=None, null=True)
changed_by = models.ForeignKey(User, on_delete=models.RESTRICT, blank=True, null=True)
history = HistoricalRecords(user_model=User)
def save(self, *args, **kwargs):
''' On save, add timestamps '''
if not self.created_at:
self.created_at = timezone.now()
self.updated_at = timezone.now()
return super(Issues, self).save(*args, **kwargs)
def __str__(self):
return self.title + " - " + self.student.name
class Meta:
verbose_name_plural = "Issues"

141
CDC_Backend/APIs/serializers.py
View File

@ -99,6 +99,59 @@ class PlacementSerializerForStudent(serializers.ModelSerializer):
]
depth = 1
class InternshipSerializerForStudent(serializers.ModelSerializer):
company_details_pdf_links = serializers.SerializerMethodField()
description_pdf_links = serializers.SerializerMethodField()
compensation_pdf_links = serializers.SerializerMethodField()
selection_procedure_details_pdf_links = serializers.SerializerMethodField()
def get_company_details_pdf_links(self, obj):
links = []
for pdf_name in obj.company_details_pdf_names:
ele = {}
link = LINK_TO_STORAGE_COMPANY_ATTACHMENT + urllib.parse.quote(obj.id + "/" + pdf_name)
ele['link'] = link
ele['name'] = pdf_name
links.append(ele)
return links
def get_description_pdf_links(self, obj):
links = []
for pdf_name in obj.description_pdf_names:
ele = {}
link = LINK_TO_STORAGE_COMPANY_ATTACHMENT + urllib.parse.quote(obj.id + "/" + pdf_name)
ele['link'] = link
ele['name'] = pdf_name
links.append(ele)
return links
def get_compensation_pdf_links(self, obj):
links = []
for pdf_name in obj.stipend_description_pdf_names:
ele = {}
link = LINK_TO_STORAGE_COMPANY_ATTACHMENT + urllib.parse.quote(obj.id + "/" + pdf_name)
ele['link'] = link
ele['name'] = pdf_name
links.append(ele)
return links
def get_selection_procedure_details_pdf_links(self, obj):
links = []
for pdf_name in obj.selection_procedure_details_pdf_names:
ele = {}
link = LINK_TO_STORAGE_COMPANY_ATTACHMENT + urllib.parse.quote(obj.id + "/" + pdf_name)
ele['link'] = link
ele['name'] = pdf_name
links.append(ele)
return links
class Meta:
model = Internship
exclude = [CONTACT_PERSON_NAME, PHONE_NUMBER, EMAIL, COMPANY_DETAILS_PDF_NAMES, DESCRIPTION_PDF_NAMES,
STIPEND_DETAILS_PDF_NAMES, SELECTION_PROCEDURE_DETAILS_PDF_NAMES, OFFER_ACCEPTED,
EMAIL_VERIFIED,
]
depth = 1
class PlacementSerializerForAdmin(serializers.ModelSerializer):
company_details_pdf_links = serializers.SerializerMethodField()
@ -152,6 +205,58 @@ class PlacementSerializerForAdmin(serializers.ModelSerializer):
COMPENSATION_DETAILS_PDF_NAMES, SELECTION_PROCEDURE_DETAILS_PDF_NAMES]
depth = 1
class InternshipSerializerForAdmin(serializers.ModelSerializer):
company_details_pdf_links = serializers.SerializerMethodField()
description_pdf_links = serializers.SerializerMethodField()
compensation_pdf_links = serializers.SerializerMethodField()
selection_procedure_details_pdf_links = serializers.SerializerMethodField()
def get_company_details_pdf_links(self, obj):
links = []
for pdf_name in obj.company_details_pdf_names:
ele = {}
link = LINK_TO_STORAGE_COMPANY_ATTACHMENT + urllib.parse.quote(obj.id + "/" + pdf_name)
ele['link'] = link
ele['name'] = pdf_name
links.append(ele)
return links
def get_description_pdf_links(self, obj):
links = []
for pdf_name in obj.description_pdf_names:
ele = {}
link = LINK_TO_STORAGE_COMPANY_ATTACHMENT + urllib.parse.quote(obj.id + "/" + pdf_name)
ele['link'] = link
ele['name'] = pdf_name
links.append(ele)
return links
def get_compensation_pdf_links(self, obj):
links = []
for pdf_name in obj.stipend_description_pdf_names:
ele = {}
link = LINK_TO_STORAGE_COMPANY_ATTACHMENT + urllib.parse.quote(obj.id + "/" + pdf_name)
ele['link'] = link
ele['name'] = pdf_name
links.append(ele)
return links
def get_selection_procedure_details_pdf_links(self, obj):
links = []
for pdf_name in obj.selection_procedure_details_pdf_names:
ele = {}
link = LINK_TO_STORAGE_COMPANY_ATTACHMENT + urllib.parse.quote(obj.id + "/" + pdf_name)
ele['link'] = link
ele['name'] = pdf_name
links.append(ele)
return links
class Meta:
model = Internship
exclude = [COMPANY_DETAILS_PDF_NAMES, DESCRIPTION_PDF_NAMES, SELECTION_PROCEDURE_DETAILS_PDF_NAMES,
STIPEND_DETAILS_PDF_NAMES]
depth = 1
class PlacementApplicationSerializer(serializers.ModelSerializer):
placement = serializers.SerializerMethodField()
@ -168,6 +273,21 @@ class PlacementApplicationSerializer(serializers.ModelSerializer):
class Meta:
model = PlacementApplication
exclude = [STUDENT, 'resume']
class InternshipApplicationSerializer(serializers.ModelSerializer):
internship = serializers.SerializerMethodField()
resume_link = serializers.SerializerMethodField()
def get_internship(self, obj):
data = InternshipSerializerForStudent(obj.internship).data
return data
def get_resume_link(self, obj):
ele = {'link': LINK_TO_STORAGE_RESUME + urllib.parse.quote(str(obj.student.roll_no) + "/" + obj.resume), 'name': obj.resume}
return ele
class Meta:
model = InternshipApplication
exclude = [STUDENT, 'resume']
class PlacementApplicationSerializerForAdmin(serializers.ModelSerializer):
@ -186,6 +306,22 @@ class PlacementApplicationSerializerForAdmin(serializers.ModelSerializer):
model = PlacementApplication
exclude = ['placement', 'resume']
class InternshipApplicationSerializerForAdmin(serializers.ModelSerializer):
student_details = serializers.SerializerMethodField()
resume_link = serializers.SerializerMethodField()
def get_student_details(self, obj):
data = StudentSerializer(obj.student).data
return data
def get_resume_link(self, obj):
ele = {'link': LINK_TO_STORAGE_RESUME + urllib.parse.quote(obj.id + "/" + obj.resume), 'name': obj.resume}
return ele
class Meta:
model = InternshipApplication
exclude = ['internship', 'resume']
class ContributorSerializer(serializers.ModelSerializer):
class Meta:
model = Contributor
@ -195,4 +331,9 @@ class ContributorSerializer(serializers.ModelSerializer):
class AutofillSerializers(serializers.ModelSerializer):
class Meta:
model = Placement
fields = '__all__'
class AutofillSerializersInternship(serializers.ModelSerializer):
class Meta:
model = Internship
fields = '__all__'

15
CDC_Backend/APIs/studentUrls.py
View File

@ -3,13 +3,14 @@ from django.urls import path
from . import studentViews
urlpatterns = [
path('login/', studentViews.login, name="Login"),
path('profile/', studentViews.studentProfile, name="Student Profile"),
path('login/', studentViews.login, name="Login"),
path('profile/', studentViews.studentProfile, name="Student Profile"),
path('getDashboard/', studentViews.getDashboard, name="Dashboard"),
path("addResume/", studentViews.addResume, name="Upload Resume"),
path("deleteResume/", studentViews.deleteResume, name="Upload Resume"),
path("submitApplication/", studentViews.submitApplication, name="Submit Application"),
path("deleteApplication/", studentViews.deleteApplication, name="Delete Application"),
path("addResume/", studentViews.addResume, name="Upload Resume"),
path("deleteResume/", studentViews.deleteResume, name="Delete Resume"),
path("submitApplication/", studentViews.submitApplication, name="Add Application"),
path("deleteApplication/", studentViews.deleteApplication, name="Delete Application"),
path("getContributorStats/", studentViews.getContributorStats, name="Get Contributor Stats"),
path("studentAcceptOffer/", studentViews.studentAcceptOffer, name="Student Accept Offer"),
path("studentAcceptOffer/", studentViews.studentAcceptOffer, name="Student Accept Offer"),
path("addIssue/",studentViews.addIssue,name= "Add Issue")
]

146
CDC_Backend/APIs/studentViews.py
View File

@ -48,6 +48,7 @@ def refresh(request):
@isAuthorized(allowed_users=[STUDENT])
def studentProfile(request, id, email, user_type):
try:
#print(id)
studentDetails = get_object_or_404(Student, id=id)
data = StudentSerializer(studentDetails).data
@ -110,9 +111,19 @@ def getDashboard(request, id, email, user_type):
placementApplications = PlacementApplication.objects.filter(student_id=id)
placementApplications = PlacementApplicationSerializer(placementApplications, many=True).data
internships = Internship.objects.filter(allowed_batch__contains=[studentDetails.batch],
allowed_branch__contains=[studentDetails.branch],
deadline_datetime__gte=datetime.datetime.now(),
offer_accepted=True, email_verified=True).order_by('deadline_datetime')
filtered_internships = internship_eligibility_filters(studentDetails, internships)
internshipsdata = InternshipSerializerForStudent(filtered_internships, many=True).data
internshipApplications = InternshipApplication.objects.filter(student_id=id)
internshipApplications = InternshipApplicationSerializer(internshipApplications, many=True).data
return Response(
{'action': "Get Dashboard - Student", 'message': "Data Found", "placements": placementsdata,
'placementApplication': placementApplications},
'placementApplication': placementApplications, 'internships':internshipsdata,'internshipApplication':internshipApplications},
status=status.HTTP_200_OK)
except Http404:
return Response({'action': "Get Dashboard - Student", 'message': 'Student Not Found'},
@ -159,24 +170,25 @@ def deleteResume(request, id, email, user_type):
@api_view(['POST'])
@isAuthorized(allowed_users=[STUDENT])
@precheck(required_data=[OPENING_TYPE, OPENING_ID, RESUME_FILE_NAME,
@precheck(required_data=[OPENING_TYPE, OPENING_ID, RESUME_FILE_NAME,ADDITIONAL_INFO
])
def submitApplication(request, id, email, user_type):
try:
data = request.data
data = request.data
student = get_object_or_404(Student, id=id)
if not student.can_apply:
return Response({'action': "Submit Application", 'message': "Student Can't Apply"},
status=status.HTTP_400_BAD_REQUEST)
# Only Allowing Applications for Placements
if data[OPENING_TYPE] == PLACEMENT:
if not student.can_apply:
return Response({'action': "Submit Application", 'message': "Student Can't Apply"},
status=status.HTTP_400_BAD_REQUEST)
if not len(PlacementApplication.objects.filter(
student_id=id, placement_id=data[OPENING_ID])):
application = PlacementApplication()
opening = get_object_or_404(Placement, id=data[OPENING_ID],
allowed_batch__contains=[student.batch],
allowed_branch__contains=[student.branch],
deadline_datetime__gte=datetime.datetime.now().date()
deadline_datetime__gte=timezone.now()
)
if not opening.offer_accepted or not opening.email_verified:
raise PermissionError("Placement Not Approved")
@ -187,6 +199,27 @@ def submitApplication(request, id, email, user_type):
application.placement = opening
else:
raise PermissionError("Application is already Submitted")
elif data[OPENING_TYPE] == INTERNSHIP:
if not student.can_apply_internship:
return Response({'action': "Submit Application", 'message': "Student Can't Apply"},
status=status.HTTP_400_BAD_REQUEST)
if not len(InternshipApplication.objects.filter(
student_id=id, internship_id=data[OPENING_ID])):
application = InternshipApplication()
opening = get_object_or_404(Internship, id=data[OPENING_ID],
allowed_batch__contains=[student.batch],
allowed_branch__contains=[student.branch],
deadline_datetime__gte=timezone.now()
)
if not opening.offer_accepted or not opening.email_verified:
raise PermissionError("Internship Not Approved")
cond_stat, cond_msg = InternshipApplicationConditions(student, opening)
if not cond_stat:
raise PermissionError(cond_msg)
application.internship = opening
else:
raise PermissionError("Application is already Submitted")
else:
raise ValueError(OPENING_TYPE + " is Invalid")
@ -239,10 +272,22 @@ def submitApplication(request, id, email, user_type):
def deleteApplication(request, id, email, user_type):
try:
data = request.data
application = get_object_or_404(PlacementApplication, id=data[APPLICATION_ID],
if OPENING_TYPE in request.data:
opening_type = request.data[OPENING_TYPE]
else:
opening_type = PLACEMENT
if opening_type==INTERNSHIP: #check whether it has header or not
application = get_object_or_404(InternshipApplication, id=data[APPLICATION_ID],
student_id=id)
if application.placement.deadline_datetime < timezone.now():
raise PermissionError("Deadline Passed")
if application.internship.deadline_datetime < timezone.now():
raise PermissionError("Deadline Passed")
else:
application = get_object_or_404(PlacementApplication, id=data[APPLICATION_ID],
student_id=id)
if application.placement.deadline_datetime < timezone.now():
raise PermissionError("Deadline Passed")
application.delete()
return Response({'action': "Delete Application", 'message': "Application Deleted"},
@ -277,19 +322,86 @@ def getContributorStats(request, id, email, user_type):
#view for sudentAcceptOffer
@api_view(['POST'])
@precheck(required_data=[OPENING_ID,"offer_accepted"])
@isAuthorized(allowed_users=[STUDENT])
def studentAcceptOffer(request, id, email, user_type):
try:
company_id = request.data['id']
student_id=request.data['profileInfo']['id']
offer_status = request.data['offerStatus']
placement_application=PlacementApplication.objects.get(placement=company_id,student=student_id)
placement_application.offer_accepted=offer_status
placement_application.save()
return Response({'action': "Accept Offer", 'message': "Updated Offer Status"},
company_id = request.data[OPENING_ID]
#student_id=request.data['profileInfo']['id'] //check this once
student_id=id
offer_accepted = request.data['offer_accepted']
if OPENING_TYPE in request.data:
opening_type = request.data[OPENING_TYPE]
else:
opening_type = PLACEMENT
if opening_type==INTERNSHIP:
application=InternshipApplication.objects.filter(internship=company_id,student=student_id,selected=True)
else:
application=PlacementApplication.objects.filter(placement=company_id,student=student_id,selected=True)
if len(application):
application[0].offer_accepted=offer_accepted
application[0].save()
return Response({'action': "Accept Offer", 'message': "Updated Offer Status"},
status=status.HTTP_200_OK)
else:
return Response({'action': "Accept Offer", 'message': "Offer Not Found"},
status=status.HTTP_404_NOT_FOUND)
except:
logger.warning("Accept Offer: " + str(sys.exc_info()))
return Response({'action': "Accept Offer", 'message': "Something Went Wrong"},
status=status.HTTP_400_BAD_REQUEST)
#view for addIssue
@api_view(['POST'])
@isAuthorized(allowed_users=[STUDENT])
@precheck(required_data=["Title","Description","opening_id","opening_type"])
def addIssue(request, id, email, user_type):
try:
data = request.data
student = get_object_or_404(Student, id=id)
issue = Issues()
issue.student = student
issue.title = data["Title"]
issue.description = data["Description"]
issue.opening_id = data["opening_id"]
issue.opening_type = data["opening_type"]
try:
if data["opening_type"]==PLACEMENT:
opening=get_object_or_404(Placement, id=data["opening_id"])
else:
opening=get_object_or_404(Internship, id=data["opening_id"])
except:
return Response({'action': "Add Issue", 'message': "Opening Not Found"},
status=status.HTTP_400_BAD_REQUEST)
issue.save()
subject=ISSUE_SUBMITTED_TEMPLATE_SUBJECT
data={
"name":student.name,
"application_type":issue.opening_type,
"company_name":opening.company_name,
"additional_info":{
"Abstract":issue.title,
"Description":issue.description
},
"email":email
}
sendEmail(email, subject, data, STUDENT_ISSUE_SUBMITTED_TEMPLATE)
#send_mail_to reps
sendEmail(CDC_REPS_EMAILS_FOR_ISSUE,"Issue Raised",data,REPS_ISSUE_SUBMITTED_TEMPLATE)
return Response({'action': "Add Issue", 'message': "Issue Added"},
status=status.HTTP_200_OK)
except Http404:
return Response({'action': "Add Issue", 'message': 'Student Not Found'},
status=status.HTTP_404_NOT_FOUND)
except:
logger.warning("Add Issue: " + str(sys.exc_info()))
return Response({'action': "Add Issue", 'message': "Something Went Wrong"},
status=status.HTTP_400_BAD_REQUEST)

1
CDC_Backend/APIs/tests.py
View File

@ -1 +0,0 @@
# Create your tests here.

0
CDC_Backend/internAPIs/__init__.py → CDC_Backend/APIs/tests/__init__.py
View File

1606
CDC_Backend/APIs/tests/test_adminView.py Normal file
View File

File diff suppressed because it is too large Load Diff

195
CDC_Backend/APIs/tests/test_companyViews.py Normal file
View File

@ -0,0 +1,195 @@
from django.test import TestCase, Client
from rest_framework import status
from rest_framework.test import APITestCase, APIClient
from django.urls import reverse
from ..models import *
import json
from ..utils import generateRandomString
import jwt
# initialize the APIClient app
client = APIClient()
class AddNewPlacementTest(APITestCase):
""" Test module for adding a new placement """
def setUp(self):
self.valid_payload = {
'company_name': 'Test Company 3', 'address': 'Test Address 3', 'company_type': 'Test Company Type 3',
'nature_of_business': 'Test Nature of Business 3', 'type_of_organisation': 'Test Type of Organisation 3',
'website': 'Test Website 3', 'company_details': 'Test Company Details 3', 'is_company_details_pdf': True,
'contact_person_name': 'Test Contact Person Name 3', 'phone_number': 1234567890, 'email': 'test3@test.com',
'city': 'Test City 3', 'state': 'Test State 3', 'country': 'Test Country 3', 'pin_code': 123456,
'designation': 'Test Designation 3', 'description': 'Test Description 3', 'job_location': 'Test Job Location 3',
'is_description_pdf': True, 'compensation_CTC': 300000, 'compensation_gross': 240000,
'compensation_take_home': 180000, 'compensation_bonus': 60000, 'is_compensation_details_pdf': True,
'allowed_branch': 'Test Allowed Branch 3', 'rs_eligible': True,
'selection_procedure_rounds': 'Test Selection Procedure Rounds 3',
'selection_procedure_details': 'Test Selection Procedure Details 3',
'is_selection_procedure_details_pdf': True, 'tentative_date_of_joining': '2022-03-01',
'tentative_no_of_offers': 30, 'other_requirements': 'Test Other Requirements 3'
}
self.invalid_payload = {
'company_name': '', 'address': 'Test Address 4', 'company_type': 'Test Company Type 4',
'nature_of_business': 'Test Nature of Business 4', 'type_of_organisation': 'Test Type of Organisation 4',
'website': 'Test Website 4', 'company_details': 'Test Company Details 4', 'is_company_details_pdf': True,
'contact_person_name': 'Test Contact Person Name 4', 'phone_number': 1234567890, 'email': 'test4@test.com',
'city': 'Test City 4', 'state': 'Test State 4', 'country': 'Test Country 4', 'pin_code': 123456,
'designation': 'Test Designation 4', 'description': 'Test Description 4', 'job_location': 'Test Job Location 4',
'is_description_pdf': True, 'compensation_CTC': 400000, 'compensation_gross': 320000,
'compensation_take_home': 240000, 'compensation_bonus': 80000, 'is_compensation_details_pdf': True,
'allowed_branch': 'Test Allowed Branch 4', 'rs_eligible': True,
'selection_procedure_rounds': 'Test Selection Procedure Rounds 4',
'selection_procedure_details': 'Test Selection Procedure Details 4',
'is_selection_procedure_details_pdf': True, 'tentative_date_of_joining': '2022-04-01',
'tentative_no_of_offers': 40, 'other_requirements': 'Test Other Requirements 4'
}
self.placement1 = Placement.objects.create(
company_name='ABC Corp', compensation_CTC=1000000, tier='1', id=generateRandomString(), allowed_branch=["CSE", "EE"], allowed_batch=["2020"], contact_person_name="test", phone_number=1234567890, email="test1@test.com", offer_accepted=True)
self.internship1 = Internship.objects.create(
company_name='ABC Corp', stipend=100000, id=generateRandomString(), allowed_branch=["CSE", "EE"], allowed_batch=["2020"], contact_person_name="test", phone_number=1234567890, email="test@gmail.com", offer_accepted=True)
self.token_placement1=jwt.encode({'opening_id': self.placement1.id,'opening_type':PLACEMENT,'email':"test1@test.com"}, os.environ.get("EMAIL_VERIFICATION_SECRET_KEY"), algorithm='HS256')
# def test_create_valid_placement(self):
# response = client.post(
# reverse('addPlacement'),
# data=json.dumps(self.valid_payload),
# content_type='application/json'
# )
# self.assertEqual(response.status_code, status.HTTP_201_CREATED)
# def test_create_invalid_placement(self):
# response = client.post(
# reverse('addPlacement'),
# data=json.dumps(self.invalid_payload),
# content_type='application/json'
# )
# self.assertEqual(response.status_code, status.HTTP_400_BAD_REQUEST)
def test_autofill_jnf_success(self):
response = client.get(
reverse('Auto FIll JNF'),{"placement_id": self.placement1.id}
)
self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assertEqual(response.data["message"], "Data Found")
self.assertEqual(response.data["placement_data"]["company_name"], "ABC Corp")
self.assertEqual(response.data["placement_data"]["compensation_CTC"], 1000000)
self.assertEqual(response.data["placement_data"]["tier"], "1")
self.assertEqual(response.data["placement_data"]["allowed_branch"], ["CSE", "EE"])
self.assertEqual(response.data["placement_data"]["allowed_batch"], ["2020"])
self.assertEqual(response.data["placement_data"]["contact_person_name"], "test")
self.assertEqual(response.data["placement_data"]["phone_number"], 1234567890)
self.assertEqual(response.data["placement_data"]["email"], "test1@test.com")
def test_autofill_jnf_WithInvalidId(self):
response = client.get(
reverse('Auto FIll JNF'),{"placement_id": generateRandomString()}
)
self.assertEqual(response.status_code, status.HTTP_404_NOT_FOUND)
self.assertEqual(response.data["message"], "Placement Not Found")
def test_autofill_inf_success(self):
response = client.get(
reverse('Auto FIll INF'),{"internship_id": self.internship1.id}
)
self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assertEqual(response.data["message"], "Data Found")
self.assertEqual(response.data["internship_data"]["company_name"], "ABC Corp")
self.assertEqual(response.data["internship_data"]["stipend"], 100000)
self.assertEqual(response.data["internship_data"]["allowed_branch"], ["CSE", "EE"])
self.assertEqual(response.data["internship_data"]["allowed_batch"], ["2020"])
self.assertEqual(response.data["internship_data"]["contact_person_name"], "test")
self.assertEqual(response.data["internship_data"]["phone_number"], 1234567890)
self.assertEqual(response.data["internship_data"]["email"], "test@gmail.com")
def test_autofill_inf_WithInvalidId(self):
response = client.get(
reverse('Auto FIll INF'),{"internship_id": generateRandomString()}
)
self.assertEqual(response.status_code, status.HTTP_404_NOT_FOUND)
self.assertEqual(response.data["message"], "Internship Not Found")
def test_verify_email_success_placement(self):
response = client.post(
reverse('Verify Email'),{"token": self.token_placement1}
)
self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assertEqual(response.data["message"], "Email Verified Successfully")
def test_verify_email_WithInvalidEmail_placement(self):
token_placement1=jwt.encode({'opening_id': self.placement1.id,'opening_type':PLACEMENT,'email':"hai@hai.com"}, os.environ.get("EMAIL_VERIFICATION_SECRET_KEY"), algorithm='HS256')
response = client.post(
reverse('Verify Email'),{"token": token_placement1}
)
self.assertEqual(response.status_code, status.HTTP_400_BAD_REQUEST)
self.assertEqual(response.data["message"], "Invalid Email")
def test_verify_email_WithInvalidOpeningId_Placement(self):
token_placement1=jwt.encode({'opening_id': generateRandomString(),'opening_type':PLACEMENT,'email':"hai@hai.com"}, os.environ.get("EMAIL_VERIFICATION_SECRET_KEY"), algorithm='HS256')
response = client.post(
reverse('Verify Email'),{"token": token_placement1}
)
self.assertEqual(response.status_code, status.HTTP_404_NOT_FOUND)
self.assertEqual(response.data["message"], "Opening Not Found")
def test_verify_email_WithInvalidOpeningType(self):
token_placement1=jwt.encode({'opening_id': self.placement1.id,'opening_type':"hai",'email':"hai@hai.com"}, os.environ.get("EMAIL_VERIFICATION_SECRET_KEY"), algorithm='HS256')
response = client.post(
reverse('Verify Email'),{"token": token_placement1}
)
self.assertEqual(response.status_code, status.HTTP_400_BAD_REQUEST)
self.assertEqual(response.data["message"], "Invalid opening type")
def test_verify_email_WithInvalidToken(self):
response = client.post(
reverse('Verify Email'),{"token": generateRandomString()}
)
self.assertEqual(response.status_code, status.HTTP_400_BAD_REQUEST)
self.assertEqual(response.data["message"], "Something went wrong")
def test_verify_email_success_Internship(self):
token_placement1=jwt.encode({'opening_id': self.internship1.id,'opening_type':INTERNSHIP,'email':"test@gmail.com"}, os.environ.get("EMAIL_VERIFICATION_SECRET_KEY"), algorithm='HS256')
response = client.post(
reverse('Verify Email'),{"token": token_placement1}
)
self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assertEqual(response.data["message"], "Email Verified Successfully")
def test_verify_email_WithInvalidEmail_Internship(self):
token_placement1=jwt.encode({'opening_id': self.internship1.id,'opening_type':INTERNSHIP,'email':"hai@hai.com"}, os.environ.get("EMAIL_VERIFICATION_SECRET_KEY"), algorithm='HS256')
response = client.post(
reverse('Verify Email'),{"token": token_placement1}
)
self.assertEqual(response.status_code, status.HTTP_400_BAD_REQUEST)
self.assertEqual(response.data["message"], "Invalid Email")
def test_verify_email_WithInvalidOpeningId_Internship(self):
token_placement1=jwt.encode({'opening_id': generateRandomString(),'opening_type':INTERNSHIP,'email':"hai@hai.com"}, os.environ.get("EMAIL_VERIFICATION_SECRET_KEY"), algorithm='HS256')
response = client.post(
reverse('Verify Email'),{"token": token_placement1}
)
self.assertEqual(response.status_code, status.HTTP_404_NOT_FOUND)
self.assertEqual(response.data["message"], "Opening Not Found")
################################################################
# 1.Write Tests For AddPlacement Functions All cases #
# #
# 2.Write Tests For AddInternship Function All cases #
# #
################################################################
def test_addPlacement_sucess(self):
self.assertTrue(True)
def test_addPlacement_failure(self):
self.assertTrue(True)

835
CDC_Backend/APIs/tests/test_studentView.py Normal file
View File

@ -0,0 +1,835 @@
# Create your tests here.
from ..models import *
from ..serializers import *
from django.test import TestCase, Client
from rest_framework import status
from rest_framework.test import APITestCase, APIClient
from django.urls import reverse
from ..utils import *
import json
from django.utils import timezone
from django.core.files.uploadedfile import SimpleUploadedFile
class StudentViewsTestCase(APITestCase):
def setUp(self):
self.client = APIClient()
self.user = User.objects.create(
email=str(os.environ.get("EMAIL_ID")),
id=str(os.environ.get("ROLL_NO")),
user_type=[STUDENT])
self.assertEqual(
self.user.email, User.objects.get(id=self.user.id).email)
self.student = Student.objects.create(
name="Test Student", id=self.user.id, resumes=["8BSLybntULgrPPm_beehyv.pdf"], roll_no=str(os.environ.get("ROLL_NO")), branch="CSE", batch="2020", phone_number=1234567890, changed_by=self.user, can_apply=True,
can_apply_internship=True, degree="bTech", cpi=7.95,
)
self.assertEqual(self.student.name,
Student.objects.get(id=self.student.id).name)
self.internship = Internship.objects.create(
company_name="Test Company", id=generateRandomString(), website="https://testwebsite.com", address="Test Address", company_type="Test Company Type", offer_accepted=True, season=["Summer"], allowed_branch=["CSE"],
allowed_batch=["2020"], contact_person_name="Test Contact Person", phone_number="1234567890", email="test@test.com", email_verified=True, stipend=10000,
)
self.placement = Placement.objects.create(
company_name="Test Company", id=generateRandomString(), website="https://testwebsite.com", address="Test Address", company_type="Test Company Type", offer_accepted=True, tier="6", allowed_branch=["CSE"], allowed_batch=["2020"],
contact_person_name="Test Contact Person", phone_number="1234567890", email="test@test.com", email_verified=True,
)
self.assertEqual(self.placement.company_name, Placement.objects.get(
id=self.placement.id).company_name)
self.internship_application = InternshipApplication.objects.create(
id=generateRandomString(), internship=self.internship, student=self.student, resume="8BSLybntULgrPPm_beehyv.pdf", selected=True
)
self.assertEqual(self.internship_application.internship.company_name, InternshipApplication.objects.get(
id=self.internship_application.id).internship.company_name)
self.placement_application = PlacementApplication.objects.create(
id=generateRandomString(), placement=self.placement, student=self.student, resume="8BSLybntULgrPPm_beehyv.pdf", selected=True
)
self.assertEqual(self.placement_application.placement.company_name, PlacementApplication.objects.get(
id=self.placement_application.id).placement.company_name)
self.issue = Issues.objects.create(
student=self.student, title="Test Issue", description="Test Issue Description", opening_id=self.internship.id,
opening_type=INTERNSHIP
)
# get token from google OAuth API
response = self.client.post(reverse('Refresh Token'), {
'refresh_token': os.environ.get("REFRESH_TOKEN")}, format='json')
self.student_token = response.data['id_token']
def test_student_accept_offer_internship(self):
url = reverse('Student Accept Offer')
data = {
'opening_id': self.internship.id,
'offer_accepted': True,
'opening_type': INTERNSHIP
}
self.client.credentials(
HTTP_AUTHORIZATION='Bearer ' + self.student_token)
response = self.client.post(url, data, format='json')
self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assertEqual(response.data['message'], 'Updated Offer Status')
self.assertEqual(InternshipApplication.objects.get(
id=self.internship_application.id).offer_accepted, True)
def test_student_accept_offer_internship_notFound(self):
url = reverse('Student Accept Offer')
data = {
'opening_id': self.internship.id,
'offer_accepted': True,
'opening_type': INTERNSHIP
}
self.internship_application.selected = False
self.internship_application.offer_accepted = False
self.internship_application.save()
self.client.credentials(
HTTP_AUTHORIZATION='Bearer ' + self.student_token)
response = self.client.post(url, data, format='json')
self.assertEqual(response.status_code, status.HTTP_404_NOT_FOUND)
self.assertEqual(response.data['message'], 'Offer Not Found')
self.assertEqual(InternshipApplication.objects.get(
id=self.internship_application.id).offer_accepted, False)
def test_delete_application_internship(self):
url = reverse('Delete Application')
data = {
'application_id': self.internship_application.id,
'opening_type': INTERNSHIP
}
self.client.credentials(
HTTP_AUTHORIZATION='Bearer ' + self.student_token)
response = self.client.post(url, data, format='json')
self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assertEqual(response.data['message'], 'Application Deleted')
self.assertEqual(InternshipApplication.objects.filter(
id=self.internship_application.id).count(), 0)
def test_delete_application_internship_deadlinePassed(self):
url = reverse('Delete Application')
data = {
'application_id': self.internship_application.id,
'opening_type': INTERNSHIP
}
self.internship.deadline_datetime = timezone.now().replace(
hour=0, minute=0, second=0, microsecond=0)
self.internship.save()
self.client.credentials(
HTTP_AUTHORIZATION='Bearer ' + self.student_token)
response = self.client.post(url, data, format='json')
self.assertEqual(response.status_code, status.HTTP_403_FORBIDDEN)
self.assertEqual(response.data['message'], 'Deadline Passed')
self.assertEqual(InternshipApplication.objects.filter(
id=self.internship_application.id).count(), 1)
def test_delete_application_internship_notFound(self):
url = reverse('Delete Application')
data = {
'application_id': self.internship_application.id,
'opening_type': INTERNSHIP
}
self.internship_application.delete()
self.client.credentials(
HTTP_AUTHORIZATION='Bearer ' + self.student_token)
response = self.client.post(url, data, format='json')
self.assertEqual(response.status_code,
status.HTTP_404_NOT_FOUND)
self.assertEqual(
response.data['message'], 'No InternshipApplication matches the given query.')
self.assertEqual(InternshipApplication.objects.filter(
id=self.internship_application.id).count(), 0)
# def test_add_application_internship(self):
# url = reverse('Delete Application')
# data = {
# 'application_id': self.internship_application.id,
# 'opening_type': INTERNSHIP
# }
# self.client.credentials(
# HTTP_AUTHORIZATION='Bearer ' + self.student_token)
# response = self.client.post(url, data, format='json')
# self.assertEqual(response.status_code, status.HTTP_200_OK)
# self.assertEqual(response.data['message'], 'Application Deleted')
# self.assertEqual(InternshipApplication.objects.filter(
# id=self.internship_application.id).count(), 0)
# # deleted existing application
# url = reverse('Add Application')
# data = {
# OPENING_ID: self.internship.id,
# OPENING_TYPE: INTERNSHIP,
# RESUME_FILE_NAME: '8BSLybntULgrPPm_beehyv.pdf',
# ADDITIONAL_INFO: []
# }
# self.client.credentials(
# HTTP_AUTHORIZATION='Bearer ' + self.student_token)
# response = self.client.post(url, data, format='json')
# self.assertEqual(response.status_code, status.HTTP_200_OK)
# self.assertEqual(response.data['message'], 'Application Submitted')
# self.assertEqual(InternshipApplication.objects.filter(
# student=self.student).count(), 1)
# self.internship_application = InternshipApplication.objects.filter(
# student=self.student)
# # self.internship.deadline_datetime = timezone.now().replace(
# # hour=0, minute=0, second=0, microsecond=0)
# # self.internship.save()
# response = self.client.post(url, data, format='json')
# self.assertEqual(response.status_code, status.HTTP_403_FORBIDDEN)
# self.assertEqual(response.data['message'],
# 'Application is already Submitted')
# self.assertEqual(InternshipApplication.objects.filter(
# student=self.student).count(), 1)
# self.internship_application.delete()
# data[OPENING_ID] = generateRandomString()
# response = self.client.post(url, data, format='json')
# self.assertEqual(response.status_code, status.HTTP_404_NOT_FOUND)
# self.assertEqual(response.data['message'],
# 'No Internship matches the given query.')
# self.assertEqual(InternshipApplication.objects.filter(
# student=self.student).count(), 0)
def test_student_accept_offer_placement(self):
url = reverse('Student Accept Offer')
data = {
'opening_id': self.placement.id,
'offer_accepted': True,
'opening_type': PLACEMENT
}
self.client.credentials(
HTTP_AUTHORIZATION='Bearer ' + self.student_token)
response = self.client.post(url, data, format='json')
self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assertEqual(response.data['message'], 'Updated Offer Status')
self.assertEqual(PlacementApplication.objects.get(
id=self.placement_application.id).offer_accepted, True)
def test_student_accept_offer_placement_offerNotFound(self):
url = reverse('Student Accept Offer')
data = {
'opening_id': self.placement.id,
'offer_accepted': True,
'opening_type': PLACEMENT
}
self.placement_application.selected = False
self.placement_application.offer_accepted = False
self.placement_application.save()
self.client.credentials(
HTTP_AUTHORIZATION='Bearer ' + self.student_token)
response = self.client.post(url, data, format='json')
self.assertEqual(response.status_code,
status.HTTP_404_NOT_FOUND)
self.assertEqual(response.data['message'], 'Offer Not Found')
self.assertEqual(PlacementApplication.objects.filter(
id=self.placement_application.id, selected=True).count(), 0)
self.assertEqual(PlacementApplication.objects.get(
id=self.placement_application.id).offer_accepted, False)
def test_delete_application_placement(self):
url = reverse('Delete Application')
data = {
'application_id': self.placement_application.id,
'opening_type': PLACEMENT
}
self.client.credentials(
HTTP_AUTHORIZATION='Bearer ' + self.student_token)
response = self.client.post(url, data, format='json')
self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assertEqual(response.data['message'], 'Application Deleted')
self.assertEqual(PlacementApplication.objects.filter(
id=self.placement_application.id).count(), 0)
def test_delete_application_placement_notFound(self):
url = reverse('Delete Application')
data = {
'application_id': self.placement_application.id,
'opening_type': PLACEMENT
}
self.placement_application.delete()
self.client.credentials(
HTTP_AUTHORIZATION='Bearer ' + self.student_token)
response = self.client.post(url, data, format='json')
self.assertEqual(response.status_code,
status.HTTP_404_NOT_FOUND)
self.assertEqual(
response.data['message'], 'No PlacementApplication matches the given query.')
self.assertEqual(PlacementApplication.objects.filter(
id=self.placement_application.id).count(), 0)
def test_delete_application_placement_deadlinePassed(self):
url = reverse('Delete Application')
data = {
'application_id': self.placement_application.id,
'opening_type': PLACEMENT
}
self.placement.deadline_datetime = timezone.now().replace(
hour=0, minute=0, second=0, microsecond=0)
self.placement.save()
self.client.credentials(
HTTP_AUTHORIZATION='Bearer ' + self.student_token)
response = self.client.post(url, data, format='json')
self.assertEqual(response.status_code,
status.HTTP_403_FORBIDDEN)
self.assertEqual(response.data['message'], 'Deadline Passed')
self.assertEqual(PlacementApplication.objects.filter(
id=self.placement_application.id).count(), 1)
def test_add_application_placement(self):
self.placement.additional_info = ["Test"]
self.placement_application.delete()
# deleted existing application
url = reverse('Add Application')
data = {
OPENING_ID: self.placement.id,
OPENING_TYPE: PLACEMENT,
RESUME_FILE_NAME: '8BSLybntULgrPPm_beehyv.pdf',
ADDITIONAL_INFO: [{"Test": "Test"}]
}
self.client.credentials(
HTTP_AUTHORIZATION='Bearer ' + self.student_token)
response = self.client.post(url, data, format='json')
self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assertEqual(response.data['message'], 'Application Submitted')
self.assertEqual(PlacementApplication.objects.filter(
student=self.student).count(), 1)
def test_add_application_placement_deadlinePassed(self):
self.placement.deadline_datetime = timezone.now().replace(
hour=0, minute=0, second=0, microsecond=0)
self.placement.save()
# deleted existing application
self.placement_application.delete()
url = reverse('Add Application')
data = {
OPENING_ID: self.placement.id,
OPENING_TYPE: PLACEMENT,
RESUME_FILE_NAME: '8BSLybntULgrPPm_beehyv.pdf',
ADDITIONAL_INFO: []
}
self.client.credentials(
HTTP_AUTHORIZATION='Bearer ' + self.student_token)
response = self.client.post(url, data, format='json')
self.assertEqual(response.status_code, status.HTTP_404_NOT_FOUND)
self.assertEqual(response.data['message'],
'No Placement matches the given query.')
self.assertEqual(PlacementApplication.objects.filter(
student=self.student, placement=self.placement).count(), 0)
def test_add_application_placement_alreadyApplied(self):
url = reverse('Add Application')
data = {
OPENING_ID: self.placement.id,
OPENING_TYPE: PLACEMENT,
RESUME_FILE_NAME: '8BSLybntULgrPPm_beehyv.pdf',
ADDITIONAL_INFO: []
}
self.client.credentials(
HTTP_AUTHORIZATION='Bearer ' + self.student_token)
response = self.client.post(url, data, format='json')
self.assertEqual(response.status_code, status.HTTP_403_FORBIDDEN)
self.assertEqual(response.data['message'],
'Application is already Submitted')
self.assertEqual(PlacementApplication.objects.filter(
student=self.student, placement=self.placement).count(), 1)
def test_add_application_placement_notFound(self):
self.placement_application.delete()
url = reverse('Add Application')
data = {
OPENING_ID: self.placement.id,
OPENING_TYPE: PLACEMENT,
RESUME_FILE_NAME: '8BSLybntULgrPPm_beehyv.pdf',
ADDITIONAL_INFO: []
}
data[OPENING_ID] = generateRandomString()
self.client.credentials(
HTTP_AUTHORIZATION='Bearer ' + self.student_token)
response = self.client.post(url, data, format='json')
self.assertEqual(response.status_code, status.HTTP_404_NOT_FOUND)
self.assertEqual(response.data['message'],
'No Placement matches the given query.')
self.assertEqual(PlacementApplication.objects.filter(
student=self.student).count(), 0)
def test_add_application_placement_notApproved(self):
self.placement_application.delete()
url = reverse('Add Application')
data = {
OPENING_ID: self.placement.id,
OPENING_TYPE: PLACEMENT,
RESUME_FILE_NAME: '8BSLybntULgrPPm_beehyv.pdf',
ADDITIONAL_INFO: []
}
self.placement.offer_accepted = False
self.placement.save()
self.client.credentials(
HTTP_AUTHORIZATION='Bearer ' + self.student_token)
response = self.client.post(url, data, format='json')
self.assertEqual(response.status_code, status.HTTP_403_FORBIDDEN)
self.assertEqual(response.data['message'],
'Placement Not Approved')
self.assertEqual(PlacementApplication.objects.filter(
student=self.student, placement=self.placement).count(), 0)
def test_add_application_placement_notEmailVerified(self):
self.placement_application.delete()
url = reverse('Add Application')
data = {
OPENING_ID: self.placement.id,
OPENING_TYPE: PLACEMENT,
RESUME_FILE_NAME: '8BSLybntULgrPPm_beehyv.pdf',
ADDITIONAL_INFO: []
}
self.placement.email_verified = False
self.placement.save()
self.client.credentials(
HTTP_AUTHORIZATION='Bearer ' + self.student_token)
response = self.client.post(url, data, format='json')
self.assertEqual(response.status_code, status.HTTP_403_FORBIDDEN)
self.assertEqual(response.data['message'],
'Placement Not Approved')
self.assertEqual(PlacementApplication.objects.filter(
student=self.student, placement=self.placement).count(), 0)
def test_add_application_placement_notRegistered(self):
self.placement_application.delete()
url = reverse('Add Application')
data = {
OPENING_ID: self.placement.id,
OPENING_TYPE: PLACEMENT,
RESUME_FILE_NAME: '8BSLybntULgrPPm_beehyv.pdf',
ADDITIONAL_INFO: []
}
self.student.can_apply = False
self.student.save()
self.client.credentials(
HTTP_AUTHORIZATION='Bearer ' + self.student_token)
response = self.client.post(url, data, format='json')
self.assertEqual(response.status_code, status.HTTP_400_BAD_REQUEST)
self.assertEqual(response.data['message'],
"Student Can't Apply")
self.assertEqual(PlacementApplication.objects.filter(
student=self.student, placement=self.placement).count(), 0)
def test_add_application_placement_InvalidOpeningtype(self):
self.placement_application.delete()
url = reverse('Add Application')
data = {
OPENING_ID: self.placement.id,
OPENING_TYPE: "Invalid",
RESUME_FILE_NAME: '8BSLybntULgrPPm_beehyv.pdf',
ADDITIONAL_INFO: []
}
self.client.credentials(
HTTP_AUTHORIZATION='Bearer ' + self.student_token)
response = self.client.post(url, data, format='json')
self.assertEqual(response.status_code, status.HTTP_400_BAD_REQUEST)
self.assertEqual(response.data['message'],
"Something Went Wrong")
self.assertEqual(PlacementApplication.objects.filter(
student=self.student, placement=self.placement).count(), 0)
def test_add_application_placement_InvalidResume(self):
self.placement_application.delete()
url = reverse('Add Application')
data = {
OPENING_ID: self.placement.id,
OPENING_TYPE: PLACEMENT,
RESUME_FILE_NAME: 'Invalid',
ADDITIONAL_INFO: []
}
self.client.credentials(
HTTP_AUTHORIZATION='Bearer ' + self.student_token)
response = self.client.post(url, data, format='json')
self.assertEqual(response.status_code, status.HTTP_404_NOT_FOUND)
self.assertEqual(response.data['message'],
"resume_file_name Not Found")
self.assertEqual(PlacementApplication.objects.filter(
student=self.student, placement=self.placement).count(), 0)
def test_add_application_placement_MissingAdditionalInfo(self):
self.placement_application.delete()
url = reverse('Add Application')
self.placement.additional_info = ["Test"]
self.placement.save()
data = {
OPENING_ID: self.placement.id,
OPENING_TYPE: PLACEMENT,
RESUME_FILE_NAME: '8BSLybntULgrPPm_beehyv.pdf',
ADDITIONAL_INFO: []
}
self.client.credentials(
HTTP_AUTHORIZATION='Bearer ' + self.student_token)
response = self.client.post(url, data, format='json')
self.assertEqual(response.status_code, status.HTTP_400_BAD_REQUEST)
self.assertEqual(response.data['message'],
"Something Went Wrong")
self.assertEqual(PlacementApplication.objects.filter(
student=self.student, placement=self.placement).count(), 0)
def test_getdashboard(self):
url = reverse('Dashboard')
self.client.credentials(
HTTP_AUTHORIZATION='Bearer ' + self.student_token)
response = self.client.get(url, format='json')
self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assertEqual(response.data['message'], 'Data Found')
internships = Internship.objects.filter(allowed_batch__contains=[self.student.batch],
allowed_branch__contains=[
self.student.branch],
deadline_datetime__gte=datetime.datetime.now(),
offer_accepted=True, email_verified=True)
placements = Placement.objects.filter(allowed_batch__contains=[self.student.batch],
allowed_branch__contains=[
self.student.branch],
deadline_datetime__gte=datetime.datetime.now(),
offer_accepted=True, email_verified=True)
filtered_internships = internship_eligibility_filters(
self.student, internships)
filtered_placements = placement_eligibility_filters(
self.student, placements)
self.assertEqual(
len(response.data['internships']), len(filtered_internships))
self.assertEqual(
len(response.data['placements']), len(filtered_placements))
self.assertEqual(len(response.data['placementApplication']), 1)
self.assertEqual(len(response.data['internshipApplication']), 1)
self.assertEqual(response.data['placementApplication'][0]
['placement']['company_name'], self.placement.company_name)
self.assertEqual(response.data['internshipApplication'][0]
['internship']['company_name'], self.internship.company_name)
# def test_get_contributor_stats(self):
# url = reverse('get_contributor_stats', kwargs={'id': self.student.id})
# self.client.credentials(HTTP_AUTHORIZATION='Bearer ' + self.contributor_token)
# response = self.client.get(url, format='json')
# self.assertEqual(response.status_code, status.HTTP_200_OK)
# self.assertEqual(response.data['message'], 'Contributor Stats Fetched')
# self.assertEqual(len(response.data['data']), 1)
# self.assertEqual(response.data['data'][0]['name'], self.contributor.name)
# self.assertEqual(response.data['data'][0]['email'], self.contributor.email)
# self.assertEqual(response.data['data'][0]['contribution_count'], self.contributor.contribution_count)
def test_add_issue(self):
url = reverse('Add Issue')
data = {
'Title': 'Test Issue 2',
'Description': 'Test Issue Description 2',
'opening_id': self.placement.id,
'opening_type': PLACEMENT
}
self.client.credentials(
HTTP_AUTHORIZATION='Bearer ' + self.student_token)
response = self.client.post(url, data, format='json')
self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assertEqual(response.data['message'], 'Issue Added')
self.assertEqual(Issues.objects.filter(
student=self.student).count(), 2)
self.assertEqual(Issues.objects.filter(
opening_id=self.placement.id).count(), 1)
self.assertEqual(Issues.objects.filter(
opening_type=PLACEMENT).count(), 1)
def test_add_application_internship(self):
self.internship.additional_info = ["Test"]
self.internship_application.delete()
# deleted existing application
url = reverse('Add Application')
data = {
OPENING_ID: self.internship.id,
OPENING_TYPE: INTERNSHIP,
RESUME_FILE_NAME: '8BSLybntULgrPPm_beehyv.pdf',
ADDITIONAL_INFO: [{"Test": "Test"}]
}
self.client.credentials(
HTTP_AUTHORIZATION='Bearer ' + self.student_token)
response = self.client.post(url, data, format='json')
self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assertEqual(response.data['message'], 'Application Submitted')
self.assertEqual(InternshipApplication.objects.filter(
student=self.student).count(), 1)
def test_add_application_internship_deadlinePassed(self):
self.internship.deadline_datetime = timezone.now().replace(hour=0, minute=0, second=0, microsecond=0)
self.internship.save()
# deleted existing application
self.internship_application.delete()
url = reverse('Add Application')
data = {
OPENING_ID: self.internship.id,
OPENING_TYPE: INTERNSHIP,
RESUME_FILE_NAME: '8BSLybntULgrPPm_beehyv.pdf',
ADDITIONAL_INFO: []
}
self.client.credentials(
HTTP_AUTHORIZATION='Bearer ' + self.student_token)
response = self.client.post(url, data, format='json')
self.assertEqual(response.status_code, status.HTTP_404_NOT_FOUND)
self.assertEqual(response.data['message'],
'No Internship matches the given query.')
self.assertEqual(InternshipApplication.objects.filter(
student=self.student, internship=self.internship).count(), 0)
def test_add_application_internship_alreadyApplied(self):
url = reverse('Add Application')
data = {
OPENING_ID: self.internship.id,
OPENING_TYPE: INTERNSHIP,
RESUME_FILE_NAME: '8BSLybntULgrPPm_beehyv.pdf',
ADDITIONAL_INFO: []
}
self.client.credentials(
HTTP_AUTHORIZATION='Bearer ' + self.student_token)
response = self.client.post(url, data, format='json')
self.assertEqual(response.status_code, status.HTTP_403_FORBIDDEN)
self.assertEqual(response.data['message'],
'Application is already Submitted')
self.assertEqual(InternshipApplication.objects.filter(
student=self.student, internship=self.internship).count(), 1)
def test_add_application_internship_notFound(self):
self.internship_application.delete()
url = reverse('Add Application')
data = {
OPENING_ID: self.internship.id,
OPENING_TYPE: INTERNSHIP,
RESUME_FILE_NAME: '8BSLybntULgrPPm_beehyv.pdf',
ADDITIONAL_INFO: []
}
data[OPENING_ID] = generateRandomString()
self.client.credentials(
HTTP_AUTHORIZATION='Bearer ' + self.student_token)
response = self.client.post(url, data, format='json')
self.assertEqual(response.status_code, status.HTTP_404_NOT_FOUND)
self.assertEqual(response.data['message'],
'No Internship matches the given query.')
self.assertEqual(InternshipApplication.objects.filter(
student=self.student).count(), 0)
def test_add_application_internship_notApproved(self):
self.internship_application.delete()
url = reverse('Add Application')
data = {
OPENING_ID: self.internship.id,
OPENING_TYPE: INTERNSHIP,
RESUME_FILE_NAME: '8BSLybntULgrPPm_beehyv.pdf',
ADDITIONAL_INFO: []
}
self.internship.offer_accepted = False
self.internship.save()
self.client.credentials(
HTTP_AUTHORIZATION='Bearer ' + self.student_token)
response = self.client.post(url, data, format='json')
self.assertEqual(response.status_code, status.HTTP_403_FORBIDDEN)
self.assertEqual(response.data['message'],
'Internship Not Approved')
self.assertEqual(InternshipApplication.objects.filter(
student=self.student, internship=self.internship).count(), 0)
def test_add_application_internship_notEmailVerified(self):
self.internship_application.delete()
url = reverse('Add Application')
data = {
OPENING_ID: self.internship.id,
OPENING_TYPE: INTERNSHIP,
RESUME_FILE_NAME: '8BSLybntULgrPPm_beehyv.pdf',
ADDITIONAL_INFO: []
}
self.internship.email_verified = False
self.internship.save()
self.client.credentials(
HTTP_AUTHORIZATION='Bearer ' + self.student_token)
response = self.client.post(url, data, format='json')
self.assertEqual(response.status_code, status.HTTP_403_FORBIDDEN)
self.assertEqual(response.data['message'],
'Internship Not Approved')
self.assertEqual(InternshipApplication.objects.filter(
student=self.student, internship=self.internship).count(), 0)
def test_add_application_internship_notRegistered(self):
self.internship_application.delete()
url = reverse('Add Application')
data = {
OPENING_ID: self.internship.id,
OPENING_TYPE: INTERNSHIP,
RESUME_FILE_NAME: '8BSLybntULgrPPm_beehyv.pdf',
ADDITIONAL_INFO: []
}
self.student.can_apply_internship = False
self.student.save()
self.client.credentials(
HTTP_AUTHORIZATION='Bearer ' + self.student_token)
response = self.client.post(url, data, format='json')
self.assertEqual(response.status_code, status.HTTP_400_BAD_REQUEST)
self.assertEqual(response.data['message'],
"Student Can't Apply")
self.assertEqual(InternshipApplication.objects.filter(
student=self.student, internship=self.internship).count(), 0)
def test_add_application_internship_InvalidOpeningtype(self):
self.internship_application.delete()
url = reverse('Add Application')
data = {
OPENING_ID: self.internship.id,
OPENING_TYPE: "Invalid",
RESUME_FILE_NAME: '8BSLybntULgrPPm_beehyv.pdf',
ADDITIONAL_INFO: []
}
self.client.credentials(
HTTP_AUTHORIZATION='Bearer ' + self.student_token)
response = self.client.post(url, data, format='json')
self.assertEqual(response.status_code, status.HTTP_400_BAD_REQUEST)
self.assertEqual(response.data['message'],
"Something Went Wrong")
self.assertEqual(InternshipApplication.objects.filter(
student=self.student, internship=self.internship).count(), 0)
def test_add_application_internship_InvalidResume(self):
self.internship_application.delete()
url = reverse('Add Application')
data = {
OPENING_ID: self.internship.id,
OPENING_TYPE: INTERNSHIP,
RESUME_FILE_NAME: 'Invalid',
ADDITIONAL_INFO: []
}
self.client.credentials(
HTTP_AUTHORIZATION='Bearer ' + self.student_token)
response = self.client.post(url, data, format='json')
self.assertEqual(response.status_code, status.HTTP_404_NOT_FOUND)
self.assertEqual(response.data['message'],
"resume_file_name Not Found")
self.assertEqual(InternshipApplication.objects.filter(
student=self.student, internship=self.internship).count(), 0)
def test_add_application_internship_MissingAdditionalInfo(self):
self.internship_application.delete()
url = reverse('Add Application')
self.internship.additional_info = ["Test"]
self.internship.save()
data = {
OPENING_ID: self.internship.id,
OPENING_TYPE: INTERNSHIP,
RESUME_FILE_NAME: '8BSLybntULgrPPm_beehyv.pdf',
ADDITIONAL_INFO: []
}
self.client.credentials(
HTTP_AUTHORIZATION='Bearer ' + self.student_token)
response = self.client.post(url, data, format='json')
self.assertEqual(response.status_code, status.HTTP_400_BAD_REQUEST)
self.assertEqual(response.data['message'],
"Something Went Wrong")
self.assertEqual(InternshipApplication.objects.filter(
student=self.student, internship=self.internship).count(), 0)
def test_getStudentProfile(self):
url = reverse('Student Profile')
self.client.credentials(
HTTP_AUTHORIZATION='Bearer ' + self.student_token)
response = self.client.get(url, format='json')
self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assertEqual(response.data['message'], 'Details Found')
self.assertEqual(response.data['details']['id'], self.student.id)
self.assertEqual(response.data['details']['roll_no'],
self.student.roll_no)
self.assertEqual(response.data['details']['name'], self.student.name)
self.assertEqual(response.data['details']['batch'], self.student.batch)
self.assertEqual(response.data['details']['branch'],
self.student.branch)
self.assertEqual(response.data['details']['phone_number'],
self.student.phone_number)
self.assertEqual(response.data['details']
['cpi'], str(self.student.cpi))
for i in range(len(response.data['details']['resume_list'])):
self.assertIn(
response.data['details']['resume_list'][i]['name'], self.student.resumes)
for i in range(len(response.data['details']['offers'])):
self.assertIn(response.data['details']['offers'][i]
['application_id'], self.placement_application.id)
def test_addResume_success(self):
pdf = SimpleUploadedFile(
'kalera.pdf', b'content', content_type='application/pdf')
url = reverse('Upload Resume')
files = {'file': pdf}
self.client.credentials(
HTTP_AUTHORIZATION='Bearer ' + self.student_token)
response = self.client.post(url, files, format='multipart')
self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assertEqual(response.data['message'], 'Resume Added')
def test_add_resume_max_limit_reached(self):
pdf = SimpleUploadedFile(
'kalera.pdf', b'content', content_type='application/pdf')
url = reverse('Upload Resume')
files = {'file': pdf}
self.client.credentials(
HTTP_AUTHORIZATION='Bearer ' + self.student_token)
self.student.resumes = ['resume1.pdf', 'resume2.pdf', 'resume3.pdf']
self.student.save()
response = self.client.post(url, files, format='multipart')
self.assertEqual(response.status_code, status.HTTP_400_BAD_REQUEST)
self.assertEqual(response.data, {
'action': 'Upload Resume', 'message': 'Max Number of Resumes limit reached'})
self.student.refresh_from_db()
self.assertEqual(len(self.student.resumes), 3)
def test_deleteResume_success(self):
destination_path = STORAGE_DESTINATION_RESUMES + \
self.student.id+'/'+"8BSLybntULgrPPm_beehyv.pdf"
# check it whats this above without this test giving error
with open(destination_path, 'w') as f:
f.write('test')
f.close()
# create a file here
url = reverse('Delete Resume')
data = {
'resume_file_name': '8BSLybntULgrPPm_beehyv.pdf'
}
self.client.credentials(
HTTP_AUTHORIZATION='Bearer ' + self.student_token)
response = self.client.post(url, data, format='json')
self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assertEqual(response.data['message'], 'Resume Deleted')
self.student.refresh_from_db()
self.assertEqual(self.student.resumes, [])
remove(destination_path)
def test_deleteResume_invalidResume(self):
url = reverse('Delete Resume')
data = {
'resume_file_name': 'Invalid'
}
self.client.credentials(
HTTP_AUTHORIZATION='Bearer ' + self.student_token)
response = self.client.post(url, data, format='json')
self.assertEqual(response.status_code, status.HTTP_404_NOT_FOUND)
self.assertEqual(response.data['message'],
'Resume Not Found')
self.student.refresh_from_db()
self.assertEqual(self.student.resumes, ['8BSLybntULgrPPm_beehyv.pdf'])
def test_deleteResume_missingResumeinStorage(self):
url = reverse('Delete Resume')
data = {
'resume_file_name': '8BSLybntULgrPPm_beehyv.pdf'
}
self.client.credentials(
HTTP_AUTHORIZATION='Bearer ' + self.student_token)
response = self.client.post(url, data, format='json')
self.assertEqual(response.status_code, status.HTTP_404_NOT_FOUND)
self.assertEqual(response.data['message'], 'File Not Found')

1
CDC_Backend/APIs/urls.py
View File

@ -8,5 +8,4 @@ urlpatterns = [
path('student/', include(studentUrls)),
path('company/', include(companyUrls)),
path('admin/', include(adminUrls)),
]

78
CDC_Backend/APIs/utils.py
View File

@ -28,7 +28,7 @@ from rest_framework import status
from rest_framework.response import Response
from .constants import *
from .models import User, PrePlacementOffer, PlacementApplication, Placement, Student, Internship
from .models import User, PrePlacementOffer, PlacementApplication, Placement, Student, Internship,InternshipApplication
logger = logging.getLogger('db')
@ -194,7 +194,7 @@ def sendEmail(email_to, subject, data, template, attachment_jnf_response=None):
else:
recipient_list = [str(email_to), ]
msg = EmailMultiAlternatives(subject, text_content, email_from, recipient_list)
msg = EmailMultiAlternatives(subject, text_content, email_from,None,bcc=recipient_list)
msg.attach_alternative(html_content, "text/html")
if attachment_jnf_response:
# logger.info(attachment_jnf_response)
@ -246,6 +246,20 @@ def PlacementApplicationConditions(student, placement):
logger.warning("Utils - PlacementApplicationConditions: " + str(sys.exc_info()))
return False, "_"
def InternshipApplicationConditions(student, internship):
try:
selected_companies = InternshipApplication.objects.filter(student=student, selected=True)
if len(selected_companies)>=1:
# print("selected companies > 1")
return False, "You have already secured a Internship"
return True, "Conditions Satisfied"
except PermissionError as e:
return False, e
except:
logger.warning("Utils - InternshipApplicationConditions: " + str(sys.exc_info()))
return False, "_"
def getTier(compensation_gross, is_psu=False):
try:
@ -370,35 +384,53 @@ def placement_eligibility_filters(student, placements):
except:
logger.warning("Utils - placement_eligibility_filters: " + str(sys.exc_info()))
return placements
def internship_eligibility_filters(student, internships):
try:
filtered_internships = []
for internship in internships.iterator():
if InternshipApplicationConditions(student, internship)[0]:
filtered_internships.append(internship)
return filtered_internships
except:
logger.warning("Utils - internship_eligibility_filters: " + str(sys.exc_info()))
return internships
@background_task.background(schedule=2)
def send_opening_notifications(placement_id):
def send_opening_notifications(opening_id, opening_type=PLACEMENT):
try:
placement = get_object_or_404(Placement, id=placement_id)
# print(opening_id, opening_type)
if opening_type == PLACEMENT:
opening = get_object_or_404(Placement, id=opening_id)
else:
opening = get_object_or_404(Internship, id=opening_id)
emails=[]
students = Student.objects.all()
for student in students.iterator():
if student.branch in placement.allowed_branch:
if student.degree == 'bTech' or placement.rs_eligible is True:
if PlacementApplicationConditions(student, placement)[0]:
if student.branch in opening.allowed_branch:
if student.degree == 'bTech' or opening.rs_eligible is True:
if (isinstance(opening,Placement) and PlacementApplicationConditions(student, opening)[0]) or (isinstance(opening,Internship) and InternshipApplicationConditions(student, opening)[0]):
try:
student_user = get_object_or_404(User, id=student.id)
subject = NOTIFY_STUDENTS_OPENING_TEMPLATE_SUBJECT.format(
company_name=placement.company_name)
deadline_datetime = placement.deadline_datetime.astimezone(pytz.timezone('Asia/Kolkata'))
data = {
"company_name": placement.company_name,
"opening_type": 'Placement',
"designation": placement.designation,
"deadline": deadline_datetime.strftime("%A, %-d %B %Y, %-I:%M %p"),
"link": PLACEMENT_OPENING_URL.format(id=placement.designation)
}
sendEmail(student_user.email, subject, data, NOTIFY_STUDENTS_OPENING_TEMPLATE)
emails.append(student_user.email)
#sendEmail(student_user.email, subject, data, NOTIFY_STUDENTS_OPENING_TEMPLATE)
except Http404:
logger.warning('Utils - send_opening_notifications: user not found : ' + student.id)
except Exception as e:
logger.warning('Utils - send_opening_notifications: For Loop' + str(e))
subject = NOTIFY_STUDENTS_OPENING_TEMPLATE_SUBJECT.format(
company_name=opening.company_name)
deadline_datetime = opening.deadline_datetime.astimezone(pytz.timezone('Asia/Kolkata'))
data = {
"company_name": opening.company_name,
"opening_type": "INTERNSHIP" if isinstance(opening, Internship) else "PLACEMENT",
"designation": opening.designation,
"deadline": deadline_datetime.strftime("%A, %-d %B %Y, %-I:%M %p"),
"link": PLACEMENT_OPENING_URL.format(id=opening.designation) if opening_type == PLACEMENT else INTERNSHIP_OPENING_URL.format(id=opening.designation),
}
sendEmail(emails, subject, data, NOTIFY_STUDENTS_OPENING_TEMPLATE) #handled multiple mailings
except:
logger.warning('Utils - send_opening_notifications: ' + str(sys.exc_info()))
return False
@ -408,11 +440,11 @@ def exception_email(opening):
opening = opening.dict()
data = {
"designation": opening["designation"],
"opening_type": PLACEMENT,
"opening_type": "INTERNSHIP" if opening["opening_type"] == "INF" else "PLACEMENT",
"company_name": opening["company_name"],
}
pdfhtml = opening_description_table_html(opening)
name = opening["company_name"] + '_jnf_response.pdf'
name = opening["company_name"] + '_jnf_response.pdf' if opening[OPENING_TYPE]!="INF" else opening["company_name"] + '_inf_response.pdf'
attachment_jnf_respone = {
"name": name,
"html": pdfhtml,
@ -435,6 +467,10 @@ def store_all_files(request):
for file in files.getlist(COMPENSATION_DETAILS_PDF):
file_location = STORAGE_DESTINATION_COMPANY_ATTACHMENTS + "temp" + '/'
saveFile(file, file_location)
#stipend details pdf for internships
for file in files.getlist(STIPEND_DETAILS_PDF):
file_location = STORAGE_DESTINATION_COMPANY_ATTACHMENTS + "temp" + '/'
saveFile(file, file_location)
# selection procedure details pdf
for file in files.getlist(SELECTION_PROCEDURE_DETAILS_PDF):
file_location = STORAGE_DESTINATION_COMPANY_ATTACHMENTS + "temp" + '/'

1
CDC_Backend/CDC_Backend/urls.py
View File

@ -4,5 +4,4 @@ from django.urls import path, include
urlpatterns = [
path('admin/', admin.site.urls),
path('api/', include('APIs.urls')),
path('internapi/', include('internAPIs.urls'))
]

10
CDC_Backend/internAPIs/admin.py
View File

@ -1,10 +0,0 @@
from django.contrib import admin
# Register your models here.
from .models import *
admin.site.register(Internship)
admin.site.register(Season)
admin.site.register(InternshipApplication)

6
CDC_Backend/internAPIs/apps.py
View File

@ -1,6 +0,0 @@
from django.apps import AppConfig
class InternapisConfig(AppConfig):
default_auto_field = 'django.db.models.BigAutoField'
name = 'internAPIs'

7
CDC_Backend/internAPIs/companyUrls.py
View File

@ -1,7 +0,0 @@
from django.urls import path
from . import companyViews
urlpatterns = [
path('addInternship/', companyViews.addInternship, name="Add Internship"),
]

4
CDC_Backend/internAPIs/companyViews.py
View File

@ -1,4 +0,0 @@
def addInternship(request):
pass

189
CDC_Backend/internAPIs/constants.py
View File

@ -1,189 +0,0 @@
import os
BRANCH_CHOICES = [
["CSE", "CSE"],
["EE", "EE"],
["ME", "ME"],
['MMAE', 'MMAE'],
['EP', 'EP'],
]
BRANCHES = [
"CSE",
"EE",
"MMAE",
"EP"
]
BATCH_CHOICES = [
["2021", "2021"],
["2020", "2020"],
["2019", "2019"],
["2018", "2018"],
["2017", "2017"],
]
OFFER_CITY_TYPE = [
['Domestic', 'Domestic'],
['International', 'International']
]
FACILITIES_PROVIDED = [
['Accommodation', 'Accommodation'],
['Food', 'Food'],
['Transport', 'Transport'],
['Medical', 'Medical'],
]
TOTAL_FACILITIES = 4
TIERS = [
['psu', 'PSU'],
['1', 'Tier 1'],
['2', 'Tier 2'],
['3', 'Tier 3'],
['4', 'Tier 4'],
['5', 'Tier 5'],
['6', 'Tier 6'],
['7', 'Tier 7'],
]
SEASON_CHOICES = (
['summer', 'Summer'],
['winter', 'Winter'],
['autumn', 'Autumn'],
['spring', 'Spring'],
)
DEGREE_CHOICES = [
['bTech', 'B.Tech'],
['ms/phd', 'MS/ PhD'],
]
TOTAL_BRANCHES = 4 # Total No of Branches
TOTAL_BATCHES = 5 # Total No of Batches
CDC_MAIl_ADDRESS = '2000'
# To be Configured Properly
CLIENT_ID = os.environ.get('GOOGLE_OAUTH_CLIENT_ID') # Google Login Client ID
# To be Configured Properly
PLACEMENT_OPENING_URL = "https://cdc.iitdh.ac.in/portal/student/dashboard/placements/{id}" # On frontend, this is the URL to be opened
LINK_TO_STORAGE_COMPANY_ATTACHMENT = "https://cdc.iitdh.ac.in/storage/Company_Attachments/"
LINK_TO_STORAGE_RESUME = "https://cdc.iitdh.ac.in/storage/Resumes/"
LINK_TO_APPLICATIONS_CSV = "https://cdc.iitdh.ac.in/storage/Application_CSV/"
LINK_TO_EMAIl_VERIFICATION_API = "https://cdc.iitdh.ac.in/portal/company/verifyEmail?token={token}"
PDF_FILES_SERVING_ENDPOINT = 'https://cdc.iitdh.ac.in/storage/Company_Attachments/' # TODO: Change this to actual URL
EMAIL = "email"
STUDENT = 'student'
ADMIN = 'admin'
SUPER_ADMIN = 's_admin'
COMPANY = 'company'
TIER = 'tier'
# To be Configured Properly
FOURTH_YEAR = '2020'
MAX_OFFERS_PER_STUDENT = 2
MAX_RESUMES_PER_STUDENT = 3
EMAIL_VERIFICATION_TOKEN_TTL = 48 # in hours
INF_TEXT_MAX_CHARACTER_COUNT = 100
INF_TEXTMEDIUM_MAX_CHARACTER_COUNT = 200
INF_TEXTAREA_MAX_CHARACTER_COUNT = 1000
INF_SMALLTEXT_MAX_CHARACTER_COUNT = 50
STORAGE_DESTINATION_RESUMES = "./Storage/Resumes/"
STORAGE_DESTINATION_COMPANY_ATTACHMENTS = './Storage/Company_Attachments/'
STORAGE_DESTINATION_APPLICATION_CSV = './Storage/Application_CSV/'
TOKEN = 'token'
RESUME_FILE_NAME = 'resume_file_name'
APPLICATION_ID = "application_id"
OPENING_ID = "opening_id"
ADDITIONAL_INFO = "additional_info"
FIELD = "field"
STATUS_ACCEPTING_APPLICATIONS = "Accepting Applications"
PLACEMENT = "Placement"
COMPANY_NAME = "company_name"
ADDRESS = "address"
COMPANY_TYPE = "company_type"
NATURE_OF_BUSINESS = "nature_of_business"
TYPE_OF_ORGANISATION = "type_of_organisation"
WEBSITE = 'website'
COMPANY_DETAILS = "company_details"
COMPANY_DETAILS_PDF = "company_details_pdf"
IS_COMPANY_DETAILS_PDF = "is_company_details_pdf"
COMPANY_DETAILS_PDF_NAMES = "company_details_pdf_names"
PHONE_NUMBER = 'phone_number'
CONTACT_PERSON_NAME = 'contact_person_name'
CITY = 'city'
STATE = 'state'
COUNTRY = 'country'
PINCODE = 'pincode'
DESIGNATION = 'designation'
DESCRIPTION = 'description'
DESCRIPTION_PDF = 'description_pdf'
DESCRIPTION_PDF_NAMES = 'description_pdf_names'
IS_DESCRIPTION_PDF = 'is_description_pdf'
OPENING_TYPE = 'opening_type'
JOB_LOCATION = 'job_location'
COMPENSATION_CTC = 'compensation_ctc'
COMPENSATION_GROSS = 'compensation_gross'
COMPENSATION_TAKE_HOME = 'compensation_take_home'
COMPENSATION_BONUS = 'compensation_bonus'
COMPENSATION_DETAILS = 'compensation_details'
COMPENSATION_DETAILS_PDF = 'compensation_details_pdf'
COMPENSATION_DETAILS_PDF_NAMES = 'compensation_details_pdf_names'
IS_COMPENSATION_DETAILS_PDF = 'is_compensation_details_pdf'
ALLOWED_BATCH = 'allowed_batch'
ALLOWED_BRANCH = 'allowed_branch'
RS_ELIGIBLE = 'rs_eligible'
BOND_DETAILS = 'bond_details'
SELECTION_PROCEDURE_ROUNDS = 'selection_procedure_rounds'
SELECTION_PROCEDURE_DETAILS = 'selection_procedure_details'
SELECTION_PROCEDURE_DETAILS_PDF = 'selection_procedure_details_pdf'
SELECTION_PROCEDURE_DETAILS_PDF_NAMES = 'selection_procedure_details_pdf_names'
IS_SELECTION_PROCEDURE_DETAILS_PDF = 'is_selection_procedure_details_pdf'
TENTATIVE_DATE_OF_JOINING = 'tentative_date_of_joining'
TENTATIVE_NO_OF_OFFERS = 'tentative_no_of_offers'
OTHER_REQUIREMENTS = 'other_requirements'
DEADLINE_DATETIME = 'deadline_datetime'
OFFER_ACCEPTED = 'offer_accepted'
EMAIL_VERIFIED = 'email_verified'
RECAPTCHA_VALUE = 'recaptchakey'
STUDENT_LIST = "student_list"
STUDENT_ID = "student_id"
STUDENT_SELECTED = "student_selected"
EXCLUDE_IN_PDF = ['id', 'is_company_details_pdf', 'offer_accepted', 'is_description_pdf',
'is_compensation_details_pdf', 'is_selection_procedure_details_pdf',
'email_verified', 'created_at']
SPECIAL_FORMAT_IN_PDF = ['website', 'company_details_pdf_names', 'description_pdf_names',
'compensation_details_pdf_names',
'selection_procedure_details_pdf_names']
COMPANY_OPENING_ERROR_TEMPLATE = "Alert! Error submitting opening for {company_name}."
COMPANY_OPENING_SUBMITTED_TEMPLATE_SUBJECT = "Notification Submitted - {id} - Career Development Cell, IIT Dharwad"
STUDENT_APPLICATION_STATUS_TEMPLATE_SUBJECT = 'Application Status - {company_name} - {id}'
STUDENT_APPLICATION_SUBMITTED_TEMPLATE_SUBJECT = 'CDC - Application Submitted - {company_name}'
STUDENT_APPLICATION_UPDATED_TEMPLATE_SUBJECT = 'CDC - Application Updated - {company_name}'
COMPANY_EMAIl_VERIFICATION_TEMPLATE_SUBJECT = 'Email Verification - Career Development Cell, IIT Dharwad'
NOTIFY_STUDENTS_OPENING_TEMPLATE_SUBJECT = 'Placement Opportunity at {company_name}'
STUDENT_APPLICATION_SUBMITTED_TEMPLATE = 'student_application_submitted.html'
COMPANY_OPENING_SUBMITTED_TEMPLATE = 'company_opening_submitted.html'
STUDENT_APPLICATION_STATUS_SELECTED_TEMPLATE = 'student_application_status_selected.html'
STUDENT_APPLICATION_STATUS_NOT_SELECTED_TEMPLATE = 'student_application_status_not_selected.html'
STUDENT_APPLICATION_UPDATED_TEMPLATE = 'student_application_updated.html'
COMPANY_EMAIL_VERIFICATION_TEMPLATE = 'company_email_verification.html'
COMPANY_JNF_RESPONSE_TEMPLATE = 'company_jnf_response.html'
NOTIFY_STUDENTS_OPENING_TEMPLATE = 'notify_students_new_opening.html'
APPLICATION_CSV_COL_NAMES = ['Applied At', 'Roll No.', 'Name', 'Email', 'Phone Number', 'Branch', 'Batch', 'CPI',
'Resume', 'Selected', ]

187
CDC_Backend/internAPIs/models.py
View File

@ -1,187 +0,0 @@
from django.db import models
# Create your models here.
from django.contrib.postgres.fields import ArrayField
from django.db import models
from django.utils import timezone
from simple_history.models import HistoricalRecords
from .constants import *
#import models from other apps
from APIs.models import User,Student
# Create your models here.
class Internship(models.Model):
id = models.CharField(blank=False, primary_key=True, max_length=15) #unique id for each internship
# Company Details
company_name = models.CharField(blank=False, max_length=INF_SMALLTEXT_MAX_CHARACTER_COUNT)
address = models.CharField(blank=False, max_length=INF_TEXTAREA_MAX_CHARACTER_COUNT)
company_type = models.CharField(blank=False, max_length=INF_SMALLTEXT_MAX_CHARACTER_COUNT)
nature_of_business = models.CharField(blank=False, max_length=INF_SMALLTEXT_MAX_CHARACTER_COUNT, default="")
type_of_organisation = models.CharField(max_length=INF_SMALLTEXT_MAX_CHARACTER_COUNT, default="", blank=False)
website = models.CharField(blank=True, max_length=INF_TEXT_MAX_CHARACTER_COUNT)
company_details = models.CharField(max_length=INF_TEXTAREA_MAX_CHARACTER_COUNT, default=None, null=True, blank=True)
company_details_pdf_names = ArrayField(
models.CharField(null=True, default=None, max_length=INF_TEXT_MAX_CHARACTER_COUNT), size=5,
default=list, blank=True)
is_company_details_pdf = models.BooleanField(blank=False, default=False)
#Company Address
city = models.CharField(blank=False, max_length=INF_SMALLTEXT_MAX_CHARACTER_COUNT, default="")
state = models.CharField(blank=False, max_length=INF_SMALLTEXT_MAX_CHARACTER_COUNT, default="")
country = models.CharField(blank=False, max_length=INF_SMALLTEXT_MAX_CHARACTER_COUNT, default="")
pin_code = models.IntegerField(blank=False, default=None, null=True)
# selection process
selection_procedure_rounds = ArrayField(
models.CharField(null=True, default=None, max_length=INF_TEXT_MAX_CHARACTER_COUNT), size=10,
default=list, blank=True)
selection_procedure_details = models.CharField(blank=True, max_length=INF_TEXTAREA_MAX_CHARACTER_COUNT)
selection_procedure_details_pdf_names = ArrayField(
models.CharField(null=True, default=None, max_length=INF_TEXT_MAX_CHARACTER_COUNT),
size=5, default=list, blank=True)
is_selection_procedure_details_pdf = models.BooleanField(blank=False, default=False)
#Internship Details
description_pdf_names = ArrayField(
models.CharField(null=True, default=None, max_length=INF_TEXT_MAX_CHARACTER_COUNT), size=5, default=list,
blank=True)
is_description_pdf = models.BooleanField(blank=False, default=False)
description = models.CharField(blank=False, max_length=INF_TEXTAREA_MAX_CHARACTER_COUNT, default=None, null=True)
interning_period_from = models.DateField(blank=False, default=None, null=True)
interning_period_to = models.DateField(blank=False, default=None, null=True)
season = models.CharField(blank=False, max_length=10, choices=SEASON_CHOICES, default=None)
is_work_from_home = models.BooleanField(blank=False, default=False)
sophomore_eligible = models.BooleanField(blank=False, default=False)
tentative_no_of_offers = models.IntegerField(blank=False, default=None, null=True)
stipend_description_pdf_names=ArrayField(
models.CharField(null=True, default=None, max_length=INF_TEXT_MAX_CHARACTER_COUNT), size=5, default=list,
blank=True)
is_stipend_description_pdf = models.BooleanField(blank=False, default=False)
stipend=models.IntegerField(blank=False, default=None, null=True)
facilities_provided=ArrayField(
models.CharField(choices=FACILITIES_PROVIDED, blank=False, max_length=20),
size=TOTAL_FACILITIES,
default=list
)
additional_facilities = models.CharField(blank=True, max_length=INF_TEXTAREA_MAX_CHARACTER_COUNT, default=None, null=True)
academic_requirements = models.CharField(blank=True, max_length=INF_TEXTAREA_MAX_CHARACTER_COUNT, default=None, null=True)
#contact details of company person
contact_person_name = models.CharField(blank=False, max_length=INF_TEXT_MAX_CHARACTER_COUNT)
phone_number = models.PositiveBigIntegerField(blank=False)
email = models.EmailField(blank=False)
contact_person_designation = models.CharField(blank=False, max_length=INF_SMALLTEXT_MAX_CHARACTER_COUNT, default="")
telephone_number = models.PositiveBigIntegerField(blank=True, default=None, null=True)
email_verified = models.BooleanField(blank=False, default=False)
#history
created_at = models.DateTimeField(blank=False, default=None, null=True)
updated_at = models.DateTimeField(blank=False, default=None, null=True)
changed_by = models.ForeignKey(User, on_delete=models.CASCADE, blank=True, null=True)
history = HistoricalRecords(user_model=User)
def format(self):
if self.company_name is not None:
self.company_name = self.company_name.strip()[:INF_SMALLTEXT_MAX_CHARACTER_COUNT]
if self.company_type is not None:
self.company_type = self.company_type.strip()[:INF_SMALLTEXT_MAX_CHARACTER_COUNT]
if self.company_details is not None:
self.company_details = self.company_details.strip()[:INF_TEXTAREA_MAX_CHARACTER_COUNT]
if self.address is not None:
self.address = self.address.strip()[:INF_TEXTAREA_MAX_CHARACTER_COUNT]
if self.nature_of_business is not None:
self.nature_of_business = self.nature_of_business.strip()[:INF_TEXTAREA_MAX_CHARACTER_COUNT]
if self.type_of_organisation is not None:
self.type_of_organisation = self.type_of_organisation.strip()[:INF_TEXTAREA_MAX_CHARACTER_COUNT]
if self.website is not None:
self.website = self.website.strip()[:INF_TEXT_MAX_CHARACTER_COUNT]
if self.contact_person_name is not None:
self.contact_person_name = self.contact_person_name.strip()[:INF_TEXT_MAX_CHARACTER_COUNT]
if self.city is not None:
self.city = self.city.strip()[:INF_SMALLTEXT_MAX_CHARACTER_COUNT]
if self.state is not None:
self.state = self.state.strip()[:INF_SMALLTEXT_MAX_CHARACTER_COUNT]
if self.country is not None:
self.country = self.country.strip()[:INF_SMALLTEXT_MAX_CHARACTER_COUNT]
if self.city_type is not None:
self.city_type = self.city_type.strip()[:INF_SMALLTEXT_MAX_CHARACTER_COUNT]
if self.selection_procedure_details is not None:
self.selection_procedure_details = self.selection_procedure_details.strip()[:INF_TEXTAREA_MAX_CHARACTER_COUNT]
if self.description is not None:
self.description = self.description.strip()[:INF_TEXTAREA_MAX_CHARACTER_COUNT]
if self.additional_facilities is not None:
self.additional_facilities = self.additional_facilities.strip()[:INF_TEXTAREA_MAX_CHARACTER_COUNT]
if self.academic_requirements is not None:
self.academic_requirements = self.academic_requirements.strip()[:INF_TEXTAREA_MAX_CHARACTER_COUNT]
if self.contact_person_designation is not None:
self.contact_person_designation = self.contact_person_designation.strip()[:INF_SMALLTEXT_MAX_CHARACTER_COUNT]
@property
def _history_user(self):
return self.changed_by
@_history_user.setter
def _history_user(self, value):
if isinstance(value, User):
self.changed_by = value
else:
self.changed_by = None
def save(self, *args, **kwargs):
''' On save, add timestamps '''
if not self.created_at:
self.created_at = timezone.now()
self.format()
self.updated_at = timezone.now()
return super(Internship, self).save(*args, **kwargs)
def __str__(self):
return self.company_name + " - " + self.id
class Season(models.Model):
season = models.CharField(max_length=10, choices=SEASON_CHOICES, unique=True)
student = models.ForeignKey(Student, on_delete=models.CASCADE, default=None)
def __str__(self):
return self.season + " Season - " + self.student.id
class InternshipApplication(models.Model):
id = models.CharField(blank=False, primary_key=True, max_length=15) #unique id for each internship
internship=models.ForeignKey(Internship,blank=False, on_delete=models.CASCADE, default=None)
student=models.ForeignKey(Student,blank=False, on_delete=models.CASCADE, default=None)
resume = models.CharField(max_length=INF_TEXT_MAX_CHARACTER_COUNT, blank=False, null=True, default=None)
additional_info = models.JSONField(blank=True, null=True, default=None)
selected = models.BooleanField(null=True, default=None, blank=True)
offer_accepted = models.BooleanField(null=True, default=None, blank=True) # True if offer accepted, False if rejected, None if not yet decided
applied_at = models.DateTimeField(blank=False, default=None, null=True)
updated_at = models.DateTimeField(blank=False, default=None, null=True)
changed_by = models.ForeignKey(User, blank=False, on_delete=models.RESTRICT, default=None, null=True)
history = HistoricalRecords(user_model=User)
def save(self, *args, **kwargs):
''' On save, add timestamps '''
if not self.applied_at:
self.applied_at = timezone.now()
self.updated_at = timezone.now()
return super(InternshipApplication, self).save(*args, **kwargs)
@property
def _history_user(self):
return self.changed_by
@_history_user.setter
def _history_user(self, value):
if isinstance(value, User):
self.changed_by = value
else:
self.changed_by = None
class Meta:
verbose_name_plural = "Internship Applications"
unique_together = ('internship', 'student')
def __str__(self):
return self.internship.company_name + " - " + self.student.name

3
CDC_Backend/internAPIs/tests.py
View File

@ -1,3 +0,0 @@
from django.test import TestCase
# Create your tests here.

7
CDC_Backend/internAPIs/urls.py
View File

@ -1,7 +0,0 @@
from django.urls import path, include
from . import companyUrls
urlpatterns = [
path('company/', include(companyUrls)),
]

3
CDC_Backend/internAPIs/views.py
View File

@ -1,3 +0,0 @@
from django.shortcuts import render
# Create your views here.

117
CDC_Backend/templates/reps_issue_submitted.html Normal file
View File

@ -0,0 +1,117 @@
<!DOCTYPE html>
<html lang="en" xmlns="http://www.w3.org/1999/xhtml">
<head>
<meta charset="UTF-8">
<meta name="viewport" content="width=device-width,initial-scale=1">
<meta name="x-apple-disable-message-reformatting">
<title></title>
<!--[if mso]>
<noscript>
<xml>
<o:OfficeDocumentSettings>
<o:PixelsPerInch>96</o:PixelsPerInch>
</o:OfficeDocumentSettings>
</xml>
</noscript>
<![endif]-->
<link rel="preconnect" href="https://fonts.gstatic.com">
<link rel="shortcut icon" href="favicon.ico"/>
<link href="https://fonts.googleapis.com/css2?family=Roboto:wght@500&display=swap" rel="stylesheet">
<style>
table, td, div, h1, p {
font-family: 'Roboto', sans-serif;
}
</style>
</head>
<body style="margin:0;padding:0;">
<table role="presentation" style="width:100%;border-collapse:collapse;border:0;border-spacing:0;background:#ffffff;">
<tr>
<td align="center" style="padding:0;">
<table role="presentation"
style="width:602px;border-collapse:collapse;border:1px solid #334878;border-spacing:0;text-align:left;">
<tr>
<td align="center" style="padding:40px 0 30px 0;background:#334878;">
<img src="https://drive.google.com/uc?id=1QTA6dB7jnsZfU1kzyUqfD_2V5xODpWFt" alt="" width="200"
style="height:auto;display:block;"/>
</td>
</tr>
<tr>
<td style="padding:36px 30px 42px 30px;">
<table role="presentation"
style="width:100%;border-collapse:collapse;border:0;border-spacing:0;">
<tr>
<td style="padding:0 0 36px 0;color:#153643;">
<h1 style="font-size:24px;margin:0 0 20px 0;font-family: 'Roboto', sans-serif;
">Hello, Folks</h1>
<p style="margin:0 0 12px 0;font-size:16px;line-height:24px;font-family: 'Roboto', sans-serif;">
We have received a issue regarding a <b>{{ application_type }}</b> opening at
<b>
{{ company_name }}</b> From {{name}}.
{% if additional_info %}
We received these additional details
<br>
<p style="margin:0 0 12px 0;font-size:16px;line-height:24px;font-family:
'Roboto', sans-serif;text-align: center">
<table style="border:solid 1px; margin: auto; text-align: center;width: 80%;
border-radius:15px; background-color: #e0e3ee">
{% for i,j in additional_info.items %}
<tr>
<td style="padding:8px 10px;color:#153643; ">{{ i }}:</td>
<td style="padding:8px 10px;color:#153643;">{{ j }}</td>
</tr>
{% endfor %}
</table>
{% endif %}
</p>
</p>
<p style="margin:0 0 12px 0;font-size:16px;line-height:24px;font-family: 'Roboto', sans-serif;">
please look into it and take necessary actions.
get in touch with the student at at <nobr><u>{{ email }}</u></nobr>
</p>
</td>
</tr>
<tr>
<td style="padding:0;">
<table role="presentation"
style="width:100%;border-collapse:collapse;border:0;border-spacing:0;">
<tr>
<td style="width:260px;padding:0;vertical-align:top;color:#334878;">
</td>
</tr>
</table>
</td>
</tr>
</table>
</td>
</tr>
<tr>
<td style="padding:30px;background:#334878;">
<table role="presentation"
style="width:100%;border-collapse:collapse;border:0;border-spacing:0;font-size:9px;font-family: 'Roboto', sans-serif;">
<tr>
<td style="padding:0;width:50%;" align="left">
<p style="margin:0;font-size:14px;line-height:16px;font-family: 'Roboto', sans-serif;color:#ffffff;">
&reg; CDC,IIT Dharwad,2021<br/>
</p>
</td>
</td>
</tr>
</table>
</td>
</tr>
</table>
</td>
</tr>
</table>
</body>
</html>

118
CDC_Backend/templates/student_issue_submitted.html Normal file
View File

@ -0,0 +1,118 @@
<!DOCTYPE html>
<html lang="en" xmlns="http://www.w3.org/1999/xhtml">
<head>
<meta charset="UTF-8">
<meta name="viewport" content="width=device-width,initial-scale=1">
<meta name="x-apple-disable-message-reformatting">
<title></title>
<!--[if mso]>
<noscript>
<xml>
<o:OfficeDocumentSettings>
<o:PixelsPerInch>96</o:PixelsPerInch>
</o:OfficeDocumentSettings>
</xml>
</noscript>
<![endif]-->
<link rel="preconnect" href="https://fonts.gstatic.com">
<link rel="shortcut icon" href="favicon.ico"/>
<link href="https://fonts.googleapis.com/css2?family=Roboto:wght@500&display=swap" rel="stylesheet">
<style>
table, td, div, h1, p {
font-family: 'Roboto', sans-serif;
}
</style>
</head>
<body style="margin:0;padding:0;">
<table role="presentation" style="width:100%;border-collapse:collapse;border:0;border-spacing:0;background:#ffffff;">
<tr>
<td align="center" style="padding:0;">
<table role="presentation"
style="width:602px;border-collapse:collapse;border:1px solid #334878;border-spacing:0;text-align:left;">
<tr>
<td align="center" style="padding:40px 0 30px 0;background:#334878;">
<img src="https://drive.google.com/uc?id=1QTA6dB7jnsZfU1kzyUqfD_2V5xODpWFt" alt="" width="200"
style="height:auto;display:block;"/>
</td>
</tr>
<tr>
<td style="padding:36px 30px 42px 30px;">
<table role="presentation"
style="width:100%;border-collapse:collapse;border:0;border-spacing:0;">
<tr>
<td style="padding:0 0 36px 0;color:#153643;">
<h1 style="font-size:24px;margin:0 0 20px 0;font-family: 'Roboto', sans-serif;
">Hello, {{ name }}</h1>
<p style="margin:0 0 12px 0;font-size:16px;line-height:24px;font-family: 'Roboto', sans-serif;">
We have received your issue regarding a <b>{{ application_type }}</b> opening at
<b>
{{ company_name }}</b>.
{% if additional_info %}
We received these additional details
<br>
<p style="margin:0 0 12px 0;font-size:16px;line-height:24px;font-family:
'Roboto', sans-serif;text-align: center">
<table style="border:solid 1px; margin: auto; text-align: center;width: 80%;
border-radius:15px; background-color: #e0e3ee">
{% for i,j in additional_info.items %}
<tr>
<td style="padding:8px 10px;color:#153643; ">{{ i }}:</td>
<td style="padding:8px 10px;color:#153643;">{{ j }}</td>
</tr>
{% endfor %}
</table>
{% endif %}
</p>
</p>
<p style="margin:0 0 12px 0;font-size:16px;line-height:24px;font-family: 'Roboto', sans-serif;">
We will get back to you if we find it legitimate. If you have any queries, please
feel to
write to
<nobr><u>cdc.support@iitdh.ac.in</u></nobr>
</p>
</td>
</tr>
<tr>
<td style="padding:0;">
<table role="presentation"
style="width:100%;border-collapse:collapse;border:0;border-spacing:0;">
<tr>
<td style="width:260px;padding:0;vertical-align:top;color:#334878;">
</td>
</tr>
</table>
</td>
</tr>
</table>
</td>
</tr>
<tr>
<td style="padding:30px;background:#334878;">
<table role="presentation"
style="width:100%;border-collapse:collapse;border:0;border-spacing:0;font-size:9px;font-family: 'Roboto', sans-serif;">
<tr>
<td style="padding:0;width:50%;" align="left">
<p style="margin:0;font-size:14px;line-height:16px;font-family: 'Roboto', sans-serif;color:#ffffff;">
&reg; CDC,IIT Dharwad,2021<br/>
</p>
</td>
</td>
</tr>
</table>
</td>
</tr>
</table>
</td>
</tr>
</table>
</body>
</html>

2
setup.sh Normal file → Executable file
View File

@ -3,7 +3,7 @@ echo "Environment setup complete"
cd CDC_Backend
python3 manage.py flush --no-input
python3 manage.py makemigrations
python3 manage.py makemigrations APIs
python3 manage.py migrate
echo "Migrations complete"