def post(self, **kwargs):
"""
"""
try:
args_data = request.args.to_dict()
post_data = request.get_json()
# print(post_data)
print(f'kwargs: {kwargs}')
testquestion_data.load(post_data)
# Check for already exising entry:
db = c_app.config.get('MONGO_DATABASE')
collection1 = 'common_test_master'
collection2 = 'common_question_master'
collection3 = 'common_user_master'
customer_id = post_data.get('customerid')
room_name = post_data.get('room_name')
columns = {"_id": 0, "deleted": 0}
queries = {"_id": ObjectId(customer_id)}
user_data = FlaskMongo.find(collection3, columns, queries)
if not user_data:
response = {
"meta": self.meta,
"message": f"user with id {customer_id} does not exists",
"status": "failure"
}
FlaskLogger.log('post',
'add_tests_info',
response,
input_data=str(post_data),
log_level='info')
return response, self.bad_code, self.headers
elif user_data[0].get("account_type") != 'teacher':
response = {
"meta": self.meta,
"message":
f"user with id {customer_id} is not allowed to create tests",
"status": "failure"
}
FlaskLogger.log('post',
'add_tests_info',
response,
input_data=str(post_data),
log_level='info')
return response, self.process_error_code, self.headers
elif user_data[0].get("no_free_trial") < 1:
response = {
"meta": self.meta,
"message":
f"user with id {customer_id} has 0 trials left. Please renew subscription.",
"status": "failure"
}
FlaskLogger.log('post',
'add_tests_info',
response,
input_data=str(post_data),
log_level='info')
return response, self.process_error_code, self.headers
else:
testid = str(uuid.uuid1()).replace("-", "")
teacher_id = kwargs.get("_id")
data1 = {
"id":
testid,
"teacher_id":
teacher_id,
"room_name":
room_name,
"details":
post_data.get("details"),
"schedule":
post_data.get("schedule"),
"duration":
post_data.get("duration"),
"start_time":
post_data.get("start_time"),
"end_time":
post_data.get("end_time"),
"no_mandatory_questions":
post_data.get("no_mandatory_questions"),
"deleted":
0
}
FlaskMongo.insert(db, collection1, data1)
for qna in post_data.get("qna"):
data2 = {
"customerid": post_data.get("customerid"),
"testid": testid,
"question": qna.get("question"),
"option1": qna.get("options")[0],
"option2": qna.get("options")[1],
"option3": qna.get("options")[2],
"option4": qna.get("options")[3],
"answer": qna.get("answer"),
"deleted": 0
}
FlaskMongo.insert(db, collection2, data2)
no_free_trial = user_data[0].get("no_free_trial")
if no_free_trial > 0:
no_free_trial = no_free_trial - 1
queries = {"_id": ObjectId(customer_id)}
updates = {"no_free_trial": no_free_trial}
FlaskMongo.update(collection3, updates, queries)
response = {
"meta": self.meta,
"message":
f"new test with id {testid} created successfully",
"status": "success"
}
FlaskLogger.log('post',
'add_tests_info',
response,
input_data=str(post_data),
log_level='info')
return response, self.success_code, self.headers
except ValidationError as e:
response = {
"meta": self.meta,
"message": "unable to process request",
"status": "failure",
"reason": format_api_error(e.messages)
}
FlaskLogger.log('post',
'add_tests_info',
response,
input_data=str(post_data),
log_level='error')
return response, self.bad_code, self.headers
except Exception as e:
# raise e
# print(e)
response = {
"meta": self.meta,
"message": "unable to process request",
"status": "failure",
"reason": str(e)
}
FlaskLogger.log('post',
'add_tests_info',
response,
input_data=str(post_data),
log_level='warning')
return response, self.exception_code, self.headers
def post(self):
'''
A Test Attempt can be new or redo
'''
try:
args_data = request.args.to_dict()
post_data = request.get_json()
post_data.update(args_data)
print(post_data)
testattempt_data.load(post_data)
student_name = post_data.get("student_name")
phone_no = post_data.get("phone_no")
print(post_data.keys())
# Check for already exising entry:
db = c_app.config.get('MONGO_DATABASE')
collection1 = 'common_test_student'
collection2 = 'common_test_student_ques_answers'
test_id = args_data.get("test_id")
student_id = args_data.get("student_id")
columns = {"_id": 0}
queries = {
"test_id": test_id,
"student_id": student_id #, "is_complete": True
}
test_data = FlaskMongo.find(collection1, columns, queries)
test_qna_data = FlaskMongo.find(collection2, columns, queries)
print(post_data)
if test_data and test_qna_data:
response = {
"meta": self.meta,
"message": f"Test {test_id} is under progress",
"status": "failure",
}
FlaskLogger.log('post',
'add_test_attempt_info',
response,
input_data=str(post_data),
log_level='info')
return response, self.bad_code, self.headers
else:
data1 = {
"student_id": student_id,
"test_id": test_id,
"student_name": student_name,
"phone_no": phone_no,
"timestamp": datetime.now().isoformat()
}
FlaskMongo.insert(db, collection1, data1)
data2 = [{
"student_id": student_id,
"test_id": test_id,
"question_id": qa.get("_id"),
"question": qa.get("question"),
"answer": qa.get("answer"),
"is_correct": qa.get("is_correct"),
"timestamp": datetime.now().isoformat()
} for qa in post_data.get('qna')]
# Bulk Insert Records Here:
FlaskMongo.insert(db, collection2, data2, bulk=True)
response = {
"meta": self.meta,
"message": f"test with id {test_id} started successfully",
"status": "success"
}
FlaskLogger.log('post',
'add_test_attempt_info',
response,
input_data=str(post_data),
log_level='info')
return response, self.success_code, self.headers
except ValidationError as e:
# raise e
# print(e)
response = {
"meta": self.meta,
"message": "unable to process request",
"status": "failure",
"errors": format_api_error(e.messages)
}
FlaskLogger.log('post',
'add_test_attempt_info',
response,
input_data=str(post_data),
log_level='error')
return response, self.bad_code, self.headers
except Exception as e:
# raise e
print(e)
response = {
"meta": self.meta,
"message": "unable to process request",
"status": "failure",
"reason": str(e)
}
FlaskLogger.log('post',
'add_test_attempt_info',
response,
input_data=str(post_data),
log_level='warning')
return response, self.exception_code, self.headers
def post(self):
'''
'''
try:
post_data = request.get_json()
teacherusers_data.load(post_data)
name = post_data.get("name")
# mobile = post_data.get("mobile")
print(post_data.keys())
# Check for already exising entry:
db = c_app.config.get('MONGO_DATABASE')
collection = 'common_user_master'
username = post_data.get("username")
phone_no = post_data.get("phone_no")
columns = {"_id": 0}
queries = {"phone_no": phone_no}
user_data = FlaskMongo.find(collection, columns, queries)
print(post_data)
if user_data != []:
response = {
"meta": self.meta,
"message": f"user {username} is already registered",
"status": "failure",
}
FlaskLogger.log('post',
f'add_{self.account_type}_info',
response,
input_data=str(post_data),
log_level='info')
return response, self.bad_code, self.headers
post_data["account_type"] = self.account_type
post_data["no_free_trial"] = 2
post_data["is_active"] = True
post_data["deleted"] = 0
post_data["created"] = datetime.now().isoformat()
FlaskMongo.insert(db, collection, post_data)
response = {
"meta": self.meta,
"message": f"new user {name} added successfully",
# "unique_id": post_data['unique_id'],
"status": "success"
}
FlaskLogger.log('post',
f'add_{self.account_type}_info',
response,
input_data=str(post_data),
log_level='info')
return response, self.success_code, self.headers
except ValidationError as e:
# raise e
# print(e)
response = {
"meta": self.meta,
"message": "unable to process request",
"status": "failure",
"errors": format_api_error(e.messages)
}
FlaskLogger.log('post',
f'add_{self.account_type}_info',
response,
input_data=str(post_data),
log_level='error')
return response, self.bad_code, self.headers
except Exception as e:
raise e
print(e)
response = {
"meta": self.meta,
"message": "unable to process request",
"status": "failure",
"reason": str(e)
}
FlaskLogger.log('post',
f'add_{self.account_type}_info',
response,
input_data=str(post_data),
log_level='warning')
return response, self.exception_code, self.headers
def post(self):
'''
'''
try:
post_data = request.get_json()
users_data.load(post_data)
name = post_data.get("name")
mobile = post_data.get("mobile")
print(post_data.keys())
if not post_data:
response = {
"meta": self.meta,
"message": "unable to process request",
"status": "failure",
}
return response, self.bad_code, self.headers
# Check for already exising entry:
db = c_app.config.get('MONGO_DATABASE')
collection = 'common_user_master'
username = post_data.get("username")
phone_no = post_data.get("phone_no")
columns = {"_id": 0}
queries = {"phone_no": phone_no}
user_data = FlaskMongo.find(collection, columns, **queries)
print(post_data)
if user_data != []:
response = {
"meta": self.meta,
"message": f"user {username} is already registered",
"status": "failure",
}
return response, self.bad_code, self.headers
post_data["no_free_trial"] = 2
post_data["is_active"] = True
post_data["deleted"] = 0
post_data["created"] = datetime.now().isoformat()
FlaskMongo.insert(db, collection, post_data)
response = {
"meta": self.meta,
"message": f"new user {name} added successfully",
# "unique_id": post_data['unique_id'],
"status": "success"
}
return response, self.success_code, self.headers
except ValidationError as e:
# raise e
# print(e)
response = {
"meta": self.meta,
"message": "unable to process request",
"status": "failure",
"errors": e.messages
}
return response, self.bad_code, self.headers
except Exception as e:
# raise e
print(e)
response = {
"meta": self.meta,
"message": "unable to process request",
"status": "failure",
"reason": str(e)
}
return response, self.exception_code, self.headers
def post(self, **kwargs):
'''
'''
try:
post_data = request.get_json()
rooms_data.load(post_data)
print(post_data.keys())
# Check for already exising entry:
db = c_app.config.get('MONGO_DATABASE')
collection = 'common_room_master'
collection2 = 'common_user_master'
teacher_id = post_data.get("teacher_id")
room_name = post_data.get("room_name")
columns = {"_id": 0}
queries = {"teacher_id": teacher_id, "room_name": room_name}
queries2 = {"_id": ObjectId(teacher_id)}
room_data = FlaskMongo.find(collection, columns, queries)
user_data = FlaskMongo.find(collection2, columns, queries2)
print(post_data)
print(f'room_data: {room_data}')
if user_data == []:
response = {
"meta": self.meta,
"message": f"teacher with id {teacher_id} does not exists",
"status": "failure",
}
FlaskLogger.log('post',
'add_rooms_info',
response,
input_data=str(post_data),
log_level='info')
return response, self.bad_code, self.headers
if room_data != []:
response = {
"meta": self.meta,
"message": f"room {room_name} is already created",
"status": "failure",
}
FlaskLogger.log('post',
'add_rooms_info',
response,
input_data=str(post_data),
log_level='info')
return response, self.bad_code, self.headers
room_id = get_uuid1()
post_data["room_id"] = room_id
post_data["deleted"] = 0
post_data["created"] = datetime.now().isoformat()
FlaskMongo.insert(db, collection, post_data)
response = {
"meta": self.meta,
"message": f"new room with id {room_id} added successfully",
"status": "success"
}
FlaskLogger.log('post',
'add_rooms_info',
response,
input_data=str(post_data),
log_level='info')
return response, self.success_code, self.headers
except ValidationError as e:
# raise e
# print(e)
response = {
"meta": self.meta,
"message": "unable to process request",
"status": "failure",
"errors": format_api_error(e.messages)
}
FlaskLogger.log('post',
'add_rooms_info',
response,
input_data=str(post_data),
log_level='error')
return response, self.bad_code, self.headers
except Exception as e:
# raise e
print(e)
response = {
"meta": self.meta,
"message": "unable to process request",
"status": "failure",
"reason": str(e)
}
FlaskLogger.log('post',
'add_rooms_info',
response,
input_data=str(post_data),
log_level='warning')
return response, self.exception_code, self.headers
