def get_all_exams_user(request):
if request.method == 'POST':
data = json.loads(request.body.decode('utf-8'))
if {'user_id', 'auth_key'}.issubset(data.keys()) and authenticate(
data['auth_key']):
try:
user = Master_Users.objects.get(id=data['user_id'])
group_mappings = User_Group_Mapping.objects.filter(user=user)
except Master_Users.DoesNotExist:
resp = Response(204, 'User doesnot exist ')
return JsonResponse(resp, status=200)
except User_Group_Mapping.DoesNotExist:
resp = Response(204, 'user and group do not match')
return JsonResponse(resp, status=200)
exams_arr = []
exams_dict = {'data': exams_arr}
for group_mapping in group_mappings:
try:
group = group_mapping.group
exams = Master_Exam.objects.filter(group=group)
except Master_Exam.DoesNotExist:
pass
for exam in exams:
temp_dict = get_exam_dict(exam)
try:
user_test = User_Test_Status.objects.get(exam=exam,
user=user)
temp_dict['status'] = user_test.status
except User_Test_Status.DoesNotExist:
temp_dict['status'] = 1
exams_arr.append(temp_dict)
return JsonResponse(exams_dict, status=200)
resp = Response(405, 'Bad Request!!')
return JsonResponse(resp, status=405)
def change_password(request):
if request.method == "POST":
data = json.loads(request.body.decode('utf-8'))
if {'auth_key', 'user_id', 'old_password', 'new_password'}.issubset(
data.keys()) and authenticate(data['auth_key']):
user_id = data['user_id']
old_password = data['old_password']
new_password = data['new_password']
try:
user_obj = Master_Users.objects.get(id=user_id)
user_cred = User_Credentials.objects.get(user=user_obj)
if (old_password == user_cred.password):
user_cred.password = new_password
user_cred.save()
resp = Response(200, "password changed successfully")
return JsonResponse(resp, status=200)
else:
resp = Response(203, "Current password is incorrect !!")
return JsonResponse(resp, status=200)
except User_Credentials.DoesNotExist:
resp = Response(203, "Wrong user name ")
return JsonResponse(resp, status=200)
resp = Response(405, 'Bad Request!!')
return JsonResponse(resp, status=405)
def forget_password(request):
if request.method == "POST":
data = json.loads(request.body.decode('utf-8'))
if {'email', 'auth_key'}.issubset(data.keys()) and authenticate(
data['auth_key']):
try:
user_obj = Master_Users.objects.get(email=data['email'])
user_cred = User_Credentials.objects.get(user=user_obj)
random_pass = ''.join(
random.choice(string.ascii_uppercase +
string.ascii_lowercase + string.digits)
for _ in range(16))
print(random_pass)
sendEmail_forgot_password(user_cred.user_name, data['email'],
random_pass)
user_cred.password = random_pass
user_cred.save()
resp = Response(200, "Password sent")
return JsonResponse(resp, status=200)
except:
resp = Response(203, 'User doesnot exist')
return JsonResponse(resp, status=200)
resp = Response(405, 'Bad Request!!')
return JsonResponse(resp, status=405)
def update_user(request):
if request.method == 'POST':
data = json.loads(request.body.decode('utf-8'))
if {
'auth_key', 'user_id', 'f_name', 'm_name', 'l_name',
'address1', 'address2', 'phone', 'city_id'
}.issubset(data.keys()) and authenticate(data['auth_key']):
try:
user_obj = Master_Users.objects.get(id=data['user_id'],
is_available=True)
city_obj = Master_City.objects.get(id=data['city_id'],
is_available=True)
except Master_Users.DoesNotExist:
resp = Response(203, "user doesnot exists")
return JsonResponse(resp, status=200)
except Master_City.DoesNotExist:
resp = Response(203, "city doesnot exists")
return JsonResponse(resp, status=200)
user_obj.first_name = data['f_name']
user_obj.last_name = data['l_name']
user_obj.middle_name = data['m_name']
user_obj.address1 = data['address1']
user_obj.address2 = data['address2']
user_obj.city = city_obj
user_obj.phone = data['phone']
user_obj.save()
resp = Response(200, "user updated successfully")
return JsonResponse(resp, status=200)
resp = Response(405, 'Bad Request!!')
return JsonResponse(resp, status=405)
def create_exam(request):
if request.method == 'POST':
data = json.loads(request.body.decode('utf-8'))
if {
'exam_name', 'exam_duration', 'group_id', 'template_id',
'show_result', 'result_timestamp', 'is_enable',
'exam_enable_time', 'auth_key'
}.issubset(data.keys()) and authenticate(data['auth_key']):
try:
group = Master_Groups.objects.get(id=data['group_id'],
is_available=True)
template = Master_Template.objects.get(id=data['template_id'],
is_available=True)
exam = Master_Exam.objects.create(
exam_name=data['exam_name'],
exam_duration=data['exam_duration'],
group=group,
template=template,
show_result_immediately=data['show_result'],
result_timestamp=data['result_timestamp'],
is_enable=data['is_enable'],
exam_enable_time=data['exam_enable_time'])
exam.save()
resp = Response(200, 'exam created successfully')
return JsonResponse(resp, status=200)
except Master_Template.DoesNotExist:
resp = Response(203, 'Template doesnot exists')
return JsonResponse(resp, status=200)
except Master_Groups.DoesNotExist:
resp = Response(203, 'Group doesnot exists')
return JsonResponse(resp, status=200)
resp = Response(405, 'Bad Request!!')
return JsonResponse(resp, status=405)
def remove_user_from_group(request):
if request.method == "POST":
data = json.loads(request.body.decode('utf-8'))
if {'group_id', 'user_array', 'auth_key'}.issubset(
data.keys()) and authenticate(data['auth_key']):
try:
group_obj = Master_Groups.objects.get(id=data['group_id'],
is_available=True)
except:
resp = Response(203, 'Group doesnot exists')
return JsonResponse(resp, status=200)
user_arr = data['user_array']
for i in range(0, len(user_arr)):
user_obj = Master_Users.objects.get(id=user_arr[i],
is_available=True)
group_mapping = User_Group_Mapping.objects.get(user=user_obj,
group=group_obj)
group_mapping.delete()
resp = Response(200, "Users deleted successfully")
return JsonResponse(resp, status=200)
resp = Response(405, 'Bad Request!!')
return JsonResponse(resp, status=405)
def get_user_subs_all(request):
if request.method == "POST":
data = json.loads(request.body.decode('utf-8'))
if {'auth_key'}.issubset(data.keys()
and authenticate(data['auth_key'])):
try:
user_subs_arr = User_Subscription_Mapping.objects.all()
arr_dict = []
data_dict = {
'data': arr_dict,
}
for user_subs in user_subs_arr:
if user_subs.start_date == None:
start = 0
end = 0
count = user_subs.count
else:
start = user_subs.start_date
end = user_subs.end_date
count = 0
user_subs_dict = {
"user": get_user_dict(user_subs.user),
"subs": get_subs_dict(user_subs.subscription),
"start": start,
"end": end,
"count": count
}
arr_dict.append(user_subs_dict)
return JsonResponse(data_dict, status=200)
except Master_Subscription.DoesNotExist:
resp = Response(203, "Subscription doesnot exists")
return JsonResponse(resp, status=200)
resp = Response(405, 'Bad Request!!')
return JsonResponse(resp, status=405)
def get_users_from_group(request):
if request.method == "POST":
data = json.loads(request.body.decode('utf-8'))
if {'group_id', 'auth_key'}.issubset(data.keys()) and authenticate(
data['auth_key']):
try:
group_obj = Master_Groups.objects.get(id=data['group_id'])
user_group_mappings = User_Group_Mapping.objects.filter(
group=group_obj)
except:
resp = Response(203, 'Group doesnot exists')
return JsonResponse(resp, status=200)
arr_dict = []
data_dict = {'data': arr_dict}
for i in range(0, len(user_group_mappings)):
user_obj = user_group_mappings[i].user
arr_dict.append(get_user_dict(user_obj))
return JsonResponse(data_dict, status=200)
resp = Response(405, 'Bad Request!!')
return JsonResponse(resp, status=405)
def validate(request):
if request.method == 'POST':
data = json.loads(request.body.decode('utf-8'))
keys = set(data.keys())
if {'username', 'password', 'auth_key'
}.issubset(keys) and authenticate(data['auth_key']):
username = data['username']
password = data['password']
else:
resp = Response(401, "Bad Request")
return JsonResponse(resp, status=200)
try:
user_obj = User_Credentials.objects.get(user_name=username,
password=password,
is_active=True)
return get_user(request)
except User_Credentials.DoesNotExist:
resp = Response(
203, "Your Credentials are incorrect, Please try again")
return JsonResponse(resp, status=200)
except:
resp = Response(477, Exception)
return JsonResponse(resp, status=477)
else:
resp = Response(405, 'Bad Request!!')
return JsonResponse(resp, status=405)
def validate_registration(request):
if request.method == "POST":
data = json.loads(request.body.decode('utf-8'))
if {'auth_key', 'email', 'reg_num'}.issubset(
data.keys()) and authenticate(data['auth_key']):
email = data['email']
registration_number = data['reg_num']
try:
user_obj = Temp_Master_Users.objects.get(
email=email, registration_code=registration_number)
now = datetime.now(timezone.utc)
reg_time = user_obj.entry_time
difference = timedelta(days=0, hours=1, minutes=0)
if (now - reg_time < difference):
if user_obj.user_type_id == 3:
#in case of student
active = True
elif user_obj.user_type_id == 2:
active = False
sendEmail_faculty(user_obj.username, user_obj.email)
master_user_obj = Master_Users.objects.create(
first_name=user_obj.first_name,
last_name=user_obj.last_name,
middle_name=user_obj.middle_name,
address1=user_obj.address1,
address2=user_obj.address2,
phone=user_obj.phone,
email=user_obj.email,
user_type_id=user_obj.user_type_id,
city=user_obj.city,
is_available=active,
)
master_user_obj.save()
user_cred = User_Credentials.objects.create(
user_name=user_obj.username,
password=user_obj.password,
user=master_user_obj,
is_active=active)
user_cred.save()
user_obj.delete()
resp = Response(
200, "Your account has been created successfully !")
return JsonResponse(resp, status=200)
else:
resp = Response(
203,
"The token has expired, Please try signing up again")
return JsonResponse(resp, status=200)
except Temp_Master_Users.DoesNotExist:
#change the message to a proper message
resp = Response(203, "Wrong Registration Number !!")
return JsonResponse(resp, status=200)
resp = Response(405, 'Bad Request!!')
return JsonResponse(resp, status=405)
def signup(request):
if request.method == 'POST':
data = json.loads(request.body.decode('utf-8'))
keys = set(data.keys())
if {
'auth_key', 'f_name', 'm_name', 'l_name', 'address1',
'address2', 'email', 'phone', 'city_id', 'username',
'password', 'user_type'
}.issubset(keys) and authenticate(data['auth_key']):
email = data['email']
#if email already exists !!
try:
temp = Temp_Master_Users.objects.get(email=email)
now = datetime.now(timezone.utc)
difference = timedelta(days=0, hours=1, minutes=0)
if (now - temp.entry_time < difference):
#can also change status to show this
resp = Response(
203, "Email already resgistered and check mail")
return JsonResponse(resp, status=200)
except Temp_Master_Users.DoesNotExist:
print("new email id ")
try:
temp = Master_Users.objects.get(email=email)
resp = Response(203,
"Email already resgistered and try login ")
return JsonResponse(resp, status=200)
except Master_Users.DoesNotExist:
print("new email id ")
city_id = data['city_id']
city_obj = Master_City.objects.get(id=city_id)
#city what to do if it does not exists
#user type decide
random_num = int(random.randint(100000, 999999))
user = Temp_Master_Users.objects.create(
username=data['username'],
password=data['password'],
first_name=data['f_name'],
last_name=data['l_name'],
middle_name=data['m_name'],
address1=data['address1'],
address2=data['address2'],
phone=data['phone'],
email=email,
user_type_id=data['user_type'],
city=city_obj,
entry_time=datetime.now(),
registration_code=random_num)
sendEmail_reg_code(data['username'], random_num, email)
user.save()
val_dict = {"email": email, "code": 0}
return JsonResponse(val_dict, status=200)
resp = Response(405, 'Bad Request!!')
return JsonResponse(resp, status=405)
def scroll_through_exam(request):
if request.method == 'POST':
data = json.loads(request.body.decode('utf-8'))
if {
'question_assigned_id', 'option_id', 'marked',
'next_question_id', 'user_id', 'exam_id', 'auth_key',
'duration'
}.issubset(data.keys()) and authenticate(data['auth_key']):
try:
#response saved
user_response = User_Question_Response.objects.get(
section_question=data['question_assigned_id'])
option_obj = Master_Option.objects.get(id=data['option_id'])
user_response.option = option_obj
except Master_Option.DoesNotExist:
user_response.option = None
except User_Question_Response.DoesNotExist:
resp = Response(203, 'Response doesnot exists')
return JsonResponse(resp, status=200)
except Master_Question.DoesNotExist:
resp = Response(
203, 'Wrong Next Question id and it doesnot exists')
return JsonResponse(resp, status=200)
user_response.marked = data['marked']
user_response.save()
#question fetched
if data['next_question_id'] != 0:
question = Master_Question.objects.get(
id=data['next_question_id'])
else:
#no question to be fetched, final question
question = None
#fetch exam and user
try:
exam_obj = Master_Exam.objects.get(id=data['exam_id'])
user_obj = Master_Users.objects.get(id=data['user_id'])
except Master_Exam.DoesNotExist:
resp = Response(203, 'Exam doesnot exists')
return JsonResponse(resp, status=200)
except Master_Users.DoesNotExist:
resp = Response(203, 'User doesnot exists')
return JsonResponse(resp, status=200)
user_question_assigned_arr = User_Question_Assigned.objects.filter(
exam=exam_obj, user=user_obj)
return JsonResponse(soul(exam_obj, user_obj, question,
user_question_assigned_arr,
data['duration']),
status=200)
resp = Response(405, 'Bad Request!!')
return JsonResponse(resp, status=405)
def modify_city(request):
if request.method == 'POST':
data = json.loads(request.body.decode('utf-8'))
if {'id', 'text', 'auth_key'}.issubset(data.keys()) and authenticate(
data['auth_key']):
city = Master_City.objects.get(id=data['id'])
city.city_text = data['text']
city.save()
resp = Response(200, "City modified")
return JsonResponse(resp, status=200)
resp = Response(405, 'Bad Request!!')
return JsonResponse(resp, status=405)
def get_all_subs(request):
if request.method == "POST":
data = json.loads(request.body.decode('utf-8'))
if {'auth_key'}.issubset(data.keys()) and authenticate(
data['auth_key']):
subs_master_arr = Master_Subscription.objects.all()
arr_dict = []
data_dict = {'data': arr_dict}
for subs_master in subs_master_arr:
arr_dict.append(get_subs_dict(subs_master))
return JsonResponse(data_dict, status=200)
resp = Response(405, 'Bad Request!!')
return JsonResponse(resp, status=405)
def get_all_groups(request):
if request.method == 'POST':
data = json.loads(request.body.decode('utf-8'))
if {'auth_key'}.issubset(data.keys()) and authenticate(
data['auth_key']):
groups = Master_Groups.objects.all()
arr_dict = []
data_dict = {'data': arr_dict}
for group in groups:
arr_dict.append(get_group_dict(group))
return JsonResponse(data_dict, status=200)
resp = Response(405, 'Bad Request!!')
return JsonResponse(resp, status=405)
def get_group(request):
if request.method == 'POST':
data = json.loads(request.body.decode('utf-8'))
if {'auth_key', 'group_id'}.issubset(data.keys()) and authenticate(
data['auth_key']):
try:
group = Master_Groups.objects.get(id=data['group_id'])
return JsonResponse(get_group_dict(group), status=200)
except:
resp = Response(203, 'Group doesnot exists')
return JsonResponse(resp, status=200)
resp = Response(405, 'Bad Request!!')
return JsonResponse(resp, status=405)
def get_exam(request):
if request.method == 'POST':
data = json.loads(request.body.decode('utf-8'))
if {'id', 'auth_key'}.issubset(data.keys()) and authenticate(
data['auth_key']):
try:
exam = Master_Exam.objects.get(id=data['id'])
return JsonResponse(get_exam_dict(exam), status=200)
except Master_Exam.DoesNotExist:
resp = Response(203, 'Exam doesnot exists')
return JsonResponse(resp, status=200)
resp = Response(405, 'Bad Request!!')
return JsonResponse(resp, status=405)
def create_subs(request):
if request.method == "POST":
data = json.loads(request.body.decode('utf-8'))
if {'auth_key', 'subs_type', 'plan_name', 'count'}.issubset(
data.keys()) and authenticate(data['auth_key']):
subs_master = Master_Subscription.objects.create(
subscription_type=data['subs_type'],
plan_name=data['plan_name'],
count_or_no_days=data['count'])
resp = Response(200, "Subscription created successfully")
return JsonResponse(resp, status=200)
resp = Response(405, 'Bad Request!!')
return JsonResponse(resp, status=405)
def delete_subtopic_perman(request):
if request.method == 'POST':
data = json.loads(request.body.decode('utf-8'))
if {'id','auth_key'}.issubset(data.keys()) and authenticate(data['auth_key']):
try:
subtopic = Master_SubTopic.objects.get(id = data['id'],is_available = True)
subtopic.delete()
resp = Response(200, "Deleted permanently")
return JsonResponse(resp, status = 200)
except Master_SubTopic.DoesNotExist:
resp = Response(203,"Subtopic doesnot exist")
return JsonResponse(resp,status = 200)
resp = Response(405,'Bad Request!!')
return JsonResponse(resp,status = 405)
def get_subs(request):
if request.method == "POST":
data = json.loads(request.body.decode('utf-8'))
if {'auth_key', 'subs_id'}.issubset(data.keys()) and authenticate(
data['auth_key']):
try:
subs_master = Master_Subscription.objects.get(
id=data['subs_id'])
return JsonResponse(get_subs_dict(subs_master), status=200)
except Master_Subscription.DoesNotExist:
resp = Response(203, "Subscription doesnot exists")
return JsonResponse(resp, status=200)
resp = Response(405, 'Bad Request!!')
return JsonResponse(resp, status=405)
def activate_topic(request):
if request.method == 'POST':
data = json.loads(request.body.decode('utf-8'))
if {'id','auth_key'}.issubset(data.keys()) and authenticate(data['auth_key']):
try:
topic = Master_Topic.objects.get(id = data['id'],is_available = False)
topic.is_available = True
topic.save()
resp = Response(200, "Activated successfully")
return JsonResponse(resp, status = 200)
except Master_SubTopic.DoesNotExist:
resp = Response(203,"topic doesnot exist")
return JsonResponse(resp,status = 200)
resp = Response(405,'Bad Request!!')
return JsonResponse(resp,status = 405)
def delete_user_test(request):
if request.method == 'POST':
data = json.loads(request.body.decode('utf-8'))
if {'id', 'auth_key'}.issubset(data.keys()) and authenticate(
data['auth_key']):
try:
user_test_status = User_Test_Status.objects.get(id=data['id'])
user_test_status.delete()
resp = Response(200, 'user_test_status deleted successfully')
return JsonResponse(resp, status=200)
except User_Test_Status.DoesNotExist:
resp = Response(203, 'Exam doesnot exists')
return JsonResponse(resp, status=200)
resp = Response(405, 'Bad Request!!')
return JsonResponse(resp, status=405)
def create_topic(request):
if request.method == 'POST':
data = json.loads(request.body.decode('utf-8'))
if {'text','auth_key'}.issubset(data.keys()) and authenticate(data['auth_key']):
try:
topic = Master_Topic.objects.get(topic_text = data['text'])
resp = Response(203,"Topic already exists")
return JsonResponse(resp, status = 200)
except Master_Topic.DoesNotExist:
topic = Master_Topic.objects.create(topic_text = data['text'])
topic.save()
resp = Response(200,"Created successfully")
return JsonResponse(resp,status = 200)
resp = Response(405,'Bad Request!!')
return JsonResponse(resp,status = 405)
def get_user_by_id(request):
if request.method == "POST":
data = json.loads(request.body.decode('utf-8'))
if {'auth_key', 'user_id'}.issubset(data.keys()) and authenticate(
data['auth_key']):
try:
user_obj = User_Credentials.objects.get(id=data['user_id'])
user = user_obj.user
return JsonResponse(get_user_dict(user), status=200)
except User_Credentials.DoesNotExist:
resp = Response(203, "user doesnot exists")
return JsonResponse(resp, status=200)
resp = Response(405, 'Bad Request!!')
return JsonResponse(resp, status=405)
def delete_exam_perman(request):
if request.method == 'POST':
data = json.loads(request.body.decode('utf-8'))
if {'id', 'auth_key'}.issubset(data.keys()) and authenticate(
data['auth_key']):
try:
exam = Master_Exam.objects.get(id=data['id'],
is_available=True)
exam.delete()
resp = Response(200, 'exam deleted successfully')
return JsonResponse(resp, status=200)
except Master_Exam.DoesNotExist:
resp = Response(203, 'Exam doesnot exists')
return JsonResponse(resp, status=200)
resp = Response(405, 'Bad Request!!')
return JsonResponse(resp, status=405)
def add_city(request):
if request.method == 'POST':
data = json.loads(request.body.decode('utf-8'))
if {'text', 'auth_key'}.issubset(data.keys()) and authenticate(
data['auth_key']):
try:
city = Master_City.objects.get(city_text=data['text'])
resp = Response(203, 'City already exists ')
return JsonResponse(resp, status=200)
except:
city = Master_City.objects.create(city_text=data['text'])
city.save()
resp = Response(200, "1")
return JsonResponse(resp, status=200)
resp = Response(405, 'Bad Request!!')
return JsonResponse(resp, status=405)
def get_city(request):
if request.method == "POST":
data = json.loads(request.body.decode('utf-8'))
if {'id', 'auth_key'}.issubset(data.keys()) and authenticate(
data['auth_key']):
city = Master_City.objects.get(id=data['id'])
arr_dict = []
city_dict = {
'id': city.id,
'name': city.city_text,
'is_available': city.is_available
}
return JsonResponse(city_dict, status=200)
resp = Response(405, 'Bad Request!!')
return JsonResponse(resp, status=405)
def delete_group_perman(request):
if request.method == "POST":
data = json.loads(request.body.decode('utf-8'))
if {'group_id', 'auth_key'}.issubset(data.keys()) and authenticate(
data['auth_key']):
try:
group_obj = Master_Groups.objects.get(id=data['group_id'],
is_available=True)
except:
resp = Response(203, 'Group doesnot exists')
return JsonResponse(resp, status=200)
group_obj.delete()
resp = Response(200, 'Group deleted successfully ')
return JsonResponse(resp, status=200)
resp = Response(405, 'Bad Request!!')
return JsonResponse(resp, status=405)
def modify_group(request):
if request.method == "POST":
data = json.loads(request.body.decode('utf-8'))
if {'group_id', 'group_name', 'auth_key'}.issubset(
data.keys()) and authenticate(data['auth_key']):
try:
group_obj = Master_Groups.objects.get(id=data['group_id'])
except:
resp = Response(203, 'Group does not exists')
return JsonResponse(resp, status=200)
group_obj.group_name = data['group_name']
group_obj.save()
resp = Response(200, 'Group modified successfully ')
return JsonResponse(resp, status=200)
resp = Response(405, 'Bad Request!!')
return JsonResponse(resp, status=405)
def activate_city(request):
if request.method == 'POST':
data = json.loads(request.body.decode('utf-8'))
if {'id', 'auth_key'}.issubset(data.keys()) and authenticate(
data['auth_key']):
try:
city = Master_City.objects.get(id=data['id'],
is_available=False)
city.is_available = True
city.save()
resp = Response(200, "City activated successfuly")
return JsonResponse(resp, status=200)
except:
resp = Response(203, 'city doesnot exist')
return JsonResponse(resp, status=200)
resp = Response(405, 'Bad Request!!')
return JsonResponse(resp, status=405)
