def get(self):
'''
'''
try:
args_data = request.args.to_dict()
print(args_data)
user = args_data.get("user", "all")
if user == "all":
queries = {"deleted": 0}
columns = {"_id": 0}
else:
queries = {"_id": ObjectId(user), "deleted": 0}
columns = {"_id": 0}
collection = 'common_user_master'
query_data = FlaskMongo.find(collection, columns, **queries)
print(f'query_data: {query_data}')
response = {"meta": self.meta, "users": query_data}
return response, self.success_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):
'''
'''
try:
post_data = request.get_json()
token_data.load(post_data)
columns = {"_id": 1, "account_type": 1}
queries = post_data
collection = 'common_user_master'
user_data = FlaskMongo.find(collection, columns, queries)
print(post_data)
print(f'user_data: {user_data}')
username = post_data.get('username')
if user_data == []:
response = {
"meta": self.meta,
# "message": f"user {username} does not exists",
"message": "please check provided credentials",
"status": "failure",
}
FlaskLogger.log('post', 'token_generation', response, log_level='info')
return response, self.auth_code, self.headers
user_data = user_data[0]
auth_token = generate_auth_token(post_data, user_data)
response = {
"meta": self.meta,
"token": auth_token,
"status": "success"
}
FlaskLogger.log('post', 'token_generation', response, 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', 'token_generation', response, log_level='error')
return response, self.bad_code, self.headers
except Exception as e:
# raise e
response = {
"meta": self.meta,
"message": "unable to process request",
"status": "failure",
"reason": str(e)
}
FlaskLogger.log('post', 'token_generation', response, log_level='warning')
return response, self.exception_code, self.headers
def put(self):
'''
'''
try:
args_data = request.args.to_dict()
post_data = request.get_json()
print(args_data)
print(post_data)
user = args_data.get("user")
# user = args_data.get("user", "all")
# print(f'condition: {(not user or post_data)}')
if not user or not post_data:
response = {
"meta": self.meta,
"message": "unable to process request",
"status": "failure",
}
return response, self.bad_code, self.headers
users_data.load(post_data, partial=True)
columns = {"_id": 0}
queries = {"_id": ObjectId(user)}
collection = 'common_user_master'
user_data = FlaskMongo.find(collection, columns, **queries)
if user_data == []:
response = {
"meta": self.meta,
"message": f"user {user} does not exists",
"status": "failure",
}
return response, self.bad_code, self.headers
updates = post_data
queries = {"_id": ObjectId(user)}
collection = 'common_user_master'
FlaskMongo.update(collection, updates, **queries)
response = {
"meta": self.meta,
"message": f"user {user} updated successfully",
"status": "success"
}
return response, self.success_code, self.headers
except Exception as e:
# raise e
response = {
"meta": self.meta,
"message": "unable to process request",
"status": "failure",
"reason": str(e)
}
return response, self.exception_code, self.headers
def get(self):
'''
'''
try:
args_data = request.args.to_dict()
test_id = args_data.get('testid')
db = c_app.config.get('MONGO_DATABASE')
collection1 = 'common_user_master'
columns = {'_id': 0}
queries = {}
aggregate_pipeline = [{
'$group': {
'_id': '$institute_name',
'count': {
'$sum': 1
}
}
}]
institute_counts = FlaskMongo.find(collection1,
columns,
queries,
aggregate=aggregate_pipeline)
columns = {'_id': 0}
queries = {}
distinct_column = 'institute_name'
institute_names = FlaskMongo.find(collection1,
columns,
queries,
distinct=True,
distinct_column=distinct_column)
total_users = db[collection1].find({}).count()
deleted_users = db[collection1].find({"deleted": 1}).count()
users = {
'total': total_users,
'deleted': deleted_users,
'active': total_users - deleted_users
}
columns = {'_id': 1}
queries = {}
users_ids = FlaskMongo.find(collection1, columns, queries)
users_ids = [uid.get('_id') for uid in users_ids]
stats = {
'users_ids': users_ids,
'users': users,
'institute_counts': institute_counts,
'institute_names': institute_names
}
response = {"meta": self.meta, "status": "success", "stats": stats}
return response, self.success_code, self.headers
except Exception as e:
# raise 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
def delete(self, **kwargs):
'''
'''
try:
args_data = request.args.to_dict()
# testquestion_data.load(args_data, partial=True)
test_id = args_data.get("testid")
queries = {'id': test_id, "deleted": 0}
columns = {'_id': 0}
collection1 = 'common_test_master'
test_data = FlaskMongo.find(collection1, columns, queries)
if not test_data:
response = {
"meta": self.meta,
"message": f"test with id {test_id} does not exists",
"status": "failure",
}
FlaskLogger.log('delete',
'del_tests_info',
response,
input_data=str(args_data),
log_level='info')
return response, self.bad_code, self.headers
elif test_data:
test_data = test_data[0]
if test_data.get('deleted') == 1:
response = {
"meta": self.meta,
"message": f"test with id {test_id} does not exists",
"status": "failure",
}
FlaskLogger.log('delete',
'del_tests_info',
response,
input_data=str(args_data),
log_level='info')
return response, self.bad_code, self.headers
updates1 = {"deleted": 1}
queries1 = {"id": test_id}
FlaskMongo.update(collection1, updates1, queries1)
collection2 = 'common_question_master'
updates2 = {"deleted": 1}
queries2 = {"testid": test_id}
FlaskMongo.update(collection2, updates2, queries2)
response = {
"meta": self.meta,
"message": f"test with id {test_id} has been deleted",
"status": "success",
}
FlaskLogger.log('delete',
'del_tests_info',
response,
input_data=str(args_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('delete',
'del_tests_info',
response,
input_data=str(args_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('delete',
'del_tests_info',
response,
input_data=str(args_data),
log_level='warning')
return response, self.exception_code, self.headers
def put(self, **kwargs):
'''
Issue: check time validators, works in post request
'''
try:
args_data = request.args.to_dict()
post_data = request.get_json()
print(post_data)
print(args_data)
args_data.update(post_data)
testquestion_data.load(post_data, partial=True)
test_id = args_data.get("testid")
queries = {'id': test_id, "deleted": 0}
columns = {'_id': 0}
collection = 'common_test_master'
query_data = FlaskMongo.find(collection, columns, queries)
if not query_data:
response = {
"meta": self.meta,
"message": f"test with id {test_id} does not exists",
"status": "failure",
}
FlaskLogger.log('put',
'mod_tests_info',
response,
input_data=str({
'ad': args_data,
'pd': post_data
}),
log_level='info')
return response, self.bad_code, self.headers
collection1 = 'common_test_master'
collection2 = 'common_question_master'
updates1 = {
"id": test_id,
"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")
}
queries1 = {"id": test_id}
FlaskMongo.update(collection1, updates1, queries1)
for qna in post_data.get("qna"):
data2 = {
"customerid": post_data.get("customerid"),
"testid": test_id,
"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")
}
updates2 = data2
queries2 = {
"_id": ObjectId(qna.get("_id")),
"testid": test_id,
"customerid": data2.get("customerid")
}
FlaskMongo.update(collection2, updates2, queries2)
response = {
"meta": self.meta,
"message": f"test with id {test_id} updated successfully",
"status": "success"
}
FlaskLogger.log('put',
'mod_tests_info',
response,
input_data=str({
'ad': args_data,
'pd': post_data
}),
log_level='info')
return response, self.success_code, self.headers
except ValidationError as e:
print(f'exception: {e}\n')
response = {
"meta": self.meta,
"message": "unable to process request",
"status": "failure",
"reason": format_api_error(e.messages)
}
FlaskLogger.log('put',
'mod_tests_info',
response,
input_data=str({
'ad': args_data,
'pd': 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('put',
'mod_tests_info',
response,
input_data=str({
'ad': args_data,
'pd': 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 put(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, partial=True)
student_name = post_data.get("student_name")
phone_no = post_data.get("phone_no")
is_complete = post_data.get("is_complete")
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
}
print(post_data)
test_data = FlaskMongo.find(collection1, columns, queries)
test_qna_data = FlaskMongo.find(collection2, columns, queries)
print(post_data)
if not test_data and not test_qna_data:
response = {
"meta": self.meta,
"message": f"No data found for Test with {test_id}",
"status": "failure",
}
FlaskLogger.log('put',
'mod_test_attempt_info',
response,
input_data=str(args_data, post_data),
log_level='info')
return response, self.bad_code, self.headers
else:
queries1 = {"student_id": student_id, "test_id": test_id}
updates1 = {
"student_name": student_name,
"phone_no": phone_no,
# "is_complete": is_complete
}
# data1["created"] = datetime.now().isoformat()
FlaskMongo.update(collection1, updates1, queries1)
for qa in post_data.get('qna'):
queries2 = {
"student_id": student_id,
"test_id": test_id,
"question_id": qa.get("_id"),
"question": qa.get("question"),
}
updates2 = {
"answer": qa.get("answer"),
"is_correct": qa.get("is_correct")
}
# Update Question Answers Here:
FlaskMongo.update(collection2, updates2, queries2)
response = {
"meta": self.meta,
"message": f"test attempt with {test_id} updated successfully",
"status": "success"
}
FlaskLogger.log('put',
'mod_test_attempt_info',
response,
input_data=str(args_data, 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('put',
'mod_test_attempt_info',
response,
input_data=str(args_data, 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('put',
'mod_test_attempt_info',
response,
input_data=str(args_data, post_data),
log_level='warning')
return response, self.exception_code, self.headers
def delete(self, **kwargs):
'''
'''
try:
args_data = request.args.to_dict()
post_data = request.get_json()
print(args_data)
# print(post_data)
teacherusers_data.load(args_data, partial=True)
userid = args_data.get("userid")
# user = args_data.get("user", "all")
# print(f'condition: {(not user or post_data)}')
columns = {"_id": 0}
queries = {"_id": ObjectId(userid)}
collection = "common_user_master"
user_data = FlaskMongo.find(collection, columns, queries)
print(f'user_data: {user_data}')
if not user_data:
response = {
"meta": self.meta,
"message": f"user with id {userid} does not exists",
"status": "failure",
}
FlaskLogger.log('delete',
f'del_{self.account_type}_info',
response,
input_data=str(args_data),
log_level='info')
return response, self.bad_code, self.headers
elif user_data:
user_data = user_data[0]
if user_data.get('deleted') == 1:
response = {
"meta": self.meta,
"message": f"user with id {userid} does not exists",
"status": "failure",
}
FlaskLogger.log('delete',
f'del_{self.account_type}_info',
response,
input_data=str(args_data),
log_level='info')
return response, self.bad_code, self.headers
updates = {"deleted": 1}
queries = {"_id": ObjectId(userid)}
collection = 'common_user_master'
FlaskMongo.update(collection, updates, queries)
response = {
"meta": self.meta,
"message": f"user with id {userid} deleted successfully",
"status": "success"
}
FlaskLogger.log('delete',
f'del_{self.account_type}_info',
response,
input_data=str(args_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('delete',
f'del_{self.account_type}_info',
response,
input_data=str(args_data),
log_level='error')
return response, self.bad_code, self.headers
except Exception as e:
# raise e
response = {
"meta": self.meta,
"message": "unable to process request",
"status": "failure",
"reason": str(e)
}
FlaskLogger.log('delete',
f'del_{self.account_type}_info',
response,
input_data=str(args_data),
log_level='warning')
return response, self.exception_code, self.headers
def put(self, **kwargs):
'''
'''
try:
args_data = request.args.to_dict()
post_data = request.get_json()
print(args_data)
print(post_data)
teacherusers_data.load(post_data, partial=True)
user = args_data.get("user")
columns = {"_id": 0}
queries = {"_id": ObjectId(user)}
collection = 'common_user_master'
user_data = FlaskMongo.find(collection, columns, queries)
if user_data == []:
response = {
"meta": self.meta,
"message": f"user {user} does not exists",
"status": "failure",
}
FlaskLogger.log('put',
f'mod_{self.account_type}_info',
response,
input_data=str(args_data, post_data),
log_level='info')
return response, self.bad_code, self.headers
updates = post_data
queries = {"_id": ObjectId(user)}
collection = 'common_user_master'
FlaskMongo.update(collection, updates, queries)
response = {
"meta": self.meta,
"message": f"user {user} updated successfully",
"status": "success"
}
FlaskLogger.log('put',
f'mod_{self.account_type}_info',
response,
input_data=str(args_data, 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('put',
f'mod_{self.account_type}_info',
response,
input_data=str(args_data, post_data),
log_level='error')
return response, self.bad_code, self.headers
except Exception as e:
# raise e
response = {
"meta": self.meta,
"message": "unable to process request",
"status": "failure",
"reason": str(e)
}
FlaskLogger.log('put',
f'mod_{self.account_type}_info',
response,
input_data=str(args_data, 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 get(self, **kwargs):
'''
'''
try:
args_data = request.args.to_dict()
print(args_data)
room_id = args_data.get("room_id", "all")
teacher_id = args_data.get("teacher_id")
pageno = int(args_data.get("pageno", 1))
cols = args_data.get('cols')
teacher_id = kwargs.get("_id")
if room_id == "all":
if pageno > 1:
skip = 10 * (pageno - 1)
else:
skip = 0
queries = {"deleted": 0, "teacher_id": teacher_id}
columns = {"_id": 0, "deleted": 0}
collection = 'common_room_master'
query_data = FlaskMongo.find(collection, columns, queries)
total_count = len(query_data)
if cols:
columns = cols.split(',')
# print(f'\ncols: {cols}\n')
# print(f'\ncols: {dict((k, 0) for k in cols)}\n')
columns1 = {"_id": 0}
columns1.update(dict((k, 1) for k in columns))
queries1 = {"deleted": 0, "teacher_id": teacher_id}
else:
queries1 = {"deleted": 0, "teacher_id": teacher_id}
columns1 = {"_id": 0, "deleted": 0}
query_data1 = FlaskMongo.find(collection,
columns1,
queries1,
skip=skip,
limit=10)
data = {}
total_pages = math.ceil(total_count / (10))
rooms_data = {
'total_count':
total_count,
'total':
total_pages,
'pageno':
pageno,
'previous':
pageno -
1 if pageno > 1 and pageno <= total_pages else None,
'next':
pageno + 1 if pageno < total_pages else None,
'data':
query_data1
}
else:
queries = {
"deleted": 0,
"teacher_id": teacher_id,
"room_id": room_id
}
columns = {"_id": 0, "deleted": 0}
collection = 'common_room_master'
query_data = FlaskMongo.find(collection, columns, queries)
if query_data:
query_data = query_data[0]
else:
query_data = {}
print(f'query_data: {query_data}')
rooms_data = query_data
response = {"meta": self.meta, "rooms_data": rooms_data}
FlaskLogger.log('get',
'rooms_info',
response,
input_data=str(args_data),
log_level='info')
return response, self.success_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('get',
'rooms_info',
response,
input_data=str(args_data),
log_level='warning')
return response, self.exception_code, self.headers
def delete(self, **kwargs):
'''
'''
try:
args_data = request.args.to_dict()
post_data = request.get_json()
print(args_data)
# print(post_data)
room_id = args_data.get("room_id")
columns = {"_id": 0}
queries = {"room_id": room_id, "deleted": 0}
collection = "common_room_master"
room_data = FlaskMongo.find(collection, columns, queries)
print(f'room_data: {room_data}')
if not room_data:
response = {
"meta": self.meta,
"message": f"room with id {room_id} does not exists",
"status": "failure",
}
FlaskLogger.log('delete',
'del_rooms_info',
response,
input_data=str(args_data),
log_level='info')
return response, self.bad_code, self.headers
elif room_data:
room_data = room_data[0]
if room_data.get('deleted') == 1:
response = {
"meta": self.meta,
"message": f"room with id {room_id} does not exists",
"status": "failure",
}
FlaskLogger.log('delete',
'del_rooms_info',
response,
input_data=str(args_data),
log_level='info')
return response, self.bad_code, self.headers
updates = {"deleted": 1}
queries = {"room_id": room_id}
collection = 'common_room_master'
FlaskMongo.update(collection, updates, queries)
response = {
"meta": self.meta,
"message": f"room with id {room_id} deleted successfully",
"status": "success"
}
FlaskLogger.log('delete',
'del_rooms_info',
response,
input_data=str(args_data),
log_level='info')
return response, self.success_code, self.headers
except Exception as e:
# raise e
response = {
"meta": self.meta,
"message": "unable to process request",
"status": "failure",
"reason": str(e)
}
FlaskLogger.log('delete',
'del_rooms_info',
response,
input_data=str(args_data),
log_level='warning')
return response, self.exception_code, self.headers
def put(self, **kwargs):
'''
'''
try:
args_data = request.args.to_dict()
post_data = request.get_json()
print(args_data)
print(post_data)
room_id = args_data.get("roomid")
rooms_data.load(post_data, partial=True)
######
db = c_app.config.get('MONGO_DATABASE')
collection = 'common_room_master'
collection2 = 'common_user_master'
teacher_id = args_data.get("teacherid")
# room_name = post_data.get("room_name")
columns = {"_id": 0}
queries = {"teacher_id": teacher_id, "room_id": room_id}
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('put',
'mod_rooms_info',
response,
input_data=str({
'ad': args_data,
'pd': post_data
}),
log_level='info')
return response, self.bad_code, self.headers
if room_data == []:
response = {
"meta": self.meta,
"message": f"room with id {room_id} does not exists",
"status": "failure",
}
FlaskLogger.log('put',
'mod_rooms_info',
response,
input_data=str({
'ad': args_data,
'pd': post_data
}),
log_level='info')
return response, self.bad_code, self.headers
######
updates = post_data
queries = {"room_id": room_id}
collection = 'common_room_master'
FlaskMongo.update(collection, updates, queries)
response = {
"meta": self.meta,
"message": f"room with id {room_id} updated successfully",
"status": "success"
}
FlaskLogger.log('put',
'mod_rooms_info',
response,
input_data=str({
'ad': args_data,
'pd': 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('put',
'mod_rooms_info',
response,
input_data=str({
'ad': args_data,
'pd': post_data
}),
log_level='error')
return response, self.bad_code, self.headers
except Exception as e:
# raise e
response = {
"meta": self.meta,
"message": "unable to process request",
"status": "failure",
"reason": str(e)
}
FlaskLogger.log('put',
'mod_rooms_info',
response,
input_data=str({
'ad': args_data,
'pd': 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 get(self, **kwargs):
'''
'''
try:
args_data = request.args.to_dict()
print(args_data)
user = args_data.get("user", "all")
pageno = int(args_data.get("pageno", 1))
if user == "all":
if pageno > 1:
skip = 10 * (pageno - 1)
else:
skip = 0
queries = {"deleted": 0, "account_type": self.account_type}
columns = {"_id": 0, "deleted": 0}
collection = 'common_user_master'
query_data1 = FlaskMongo.find(collection, columns, queries)
queries = {"deleted": 0, "account_type": self.account_type}
columns = {"_id": 0, "deleted": 0}
query_data2 = FlaskMongo.find(collection,
columns,
queries,
skip=skip,
limit=10)
total_count = len(query_data1)
total_pages = math.ceil(total_count / (10))
query_data = {
'total':
total_pages,
'pageno':
pageno,
'previous':
pageno -
1 if pageno > 1 and pageno <= total_pages else None,
'next':
pageno + 1 if pageno < total_pages else None,
'data':
query_data2
}
else:
queries = {
"_id": ObjectId(user),
"deleted": 0,
"account_type": self.account_type
}
columns = {"_id": 0, "deleted": 0}
collection = 'common_user_master'
query_data = FlaskMongo.find(collection, columns, queries)
if query_data:
query_data = query_data[0]
else:
query_data = {}
print(f'query_data: {query_data}')
response = {"meta": self.meta, "users": query_data}
FlaskLogger.log('get',
f'{self.account_type}_info',
response,
input_data=str(args_data),
log_level='info')
return response, self.success_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('get',
f'{self.account_type}_info',
response,
input_data=str(args_data),
log_level='warning')
return response, self.exception_code, self.headers
def put(self):
'''
'''
try:
args_data = request.args.to_dict()
post_data = request.get_json()
post_data.update(args_data)
testattempt_data.load(post_data, partial=True)
# 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)
if not test_data:
response = {
"meta":
self.meta,
"message":
"unable to process request",
"status":
"failure",
"reason":
f"No test with id {test_id} found for student id {student_id}"
}
FlaskLogger.log('put',
'mod_test_complete_info',
response,
input_data=str(args_data, post_data),
log_level='info')
return response, self.bad_code, self.headers
else:
updates1 = {'is_complete': post_data.get('is_complete')}
queries1 = {"student_id": student_id, "test_id": test_id}
FlaskMongo.update(collection1, updates1, queries1)
response = {
"meta": self.meta,
"message":
f"Test with id {test_id} updated for student id {student_id}",
"status": "success"
}
FlaskLogger.log('put',
'mod_test_complete_info',
response,
input_data=str(args_data, 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('put',
'mod_test_complete_info',
response,
input_data=str(args_data, 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('put',
'mod_test_complete_info',
response,
input_data=str(args_data, post_data),
log_level='warning')
return response, self.exception_code, self.headers
def post(self):
'''
'''
try:
args_data = request.args.to_dict()
post_data = request.get_json()
reset_trial_data.load(post_data)
user_id = post_data.get("userid")
collection = "common_user_master"
queries = {"_id": ObjectId(user_id)}
columns = {"_id": 0}
user_data = FlaskMongo.find(collection, columns, queries)
if not user_data:
response = {
"meta": self.meta,
"message": f"user with id {user_id} does not exists",
"status": "failure"
}
# FlaskLogger.log('post', 'reset_trial', response, log_level='debug')
FlaskLogger.log('post',
'reset_trial',
response,
log_level='info')
# FlaskLogger.log('post', 'reset_trial', response, log_level='warning')
# FlaskLogger.log('post', 'reset_trial', response, log_level='error')
# FlaskLogger.log('post', 'reset_trial', response, log_level='critical')
return response, self.bad_code, self.headers
else:
if args_data:
no_free_trial = int(args_data.get('no_free_trial'))
else:
no_free_trial = 2
updates = {"no_free_trial": no_free_trial}
FlaskMongo.update(collection, updates, queries)
response = {
"meta": self.meta,
"message":
f"trial for user with id {user_id} has been reset",
"status": "success"
}
FlaskLogger.log('post',
'reset_trial',
response,
log_level='info')
return response, self.success_code, self.headers
except ValidationError as e:
print(e)
response = {
"meta": self.meta,
"message": "unable to process request",
"status": "failure",
"reason": format_api_error(e.messages)
}
FlaskLogger.log('post', 'reset_trial', response, 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',
'reset_trial',
response,
log_level='warning')
return response, self.exception_code, self.headers
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 get(self):
'''
'''
try:
args_data = request.args.to_dict()
print(args_data)
student_id = args_data.get('studentid')
collection1 = 'common_test_student'
# collection2 = 'common_test_master'
columns = {'_id': 0, "test_id": 1, "is_complete": 1}
queries1 = {'student_id': student_id}
query_data1 = FlaskMongo.find(collection1, columns, queries1)
# queries2 = {'id': student_id}
# query_data2 = FlaskMongo.find(collection2, columns, queries2)
if query_data1:
# query_data1 = query_data1[0]
print(f'query_data1: {query_data1}')
# query_data1 = query_data1[0]
# print(query_data1)
stats = {
'total': len(query_data1),
'complete': 0,
'incomplete': 0,
'test-ids': []
}
for qd in query_data1:
if qd.get('is_complete'):
stats['complete'] = stats['complete'] + 1
stats['test-ids'].append(qd.get('test_id'))
stats['incomplete'] = stats['total'] - stats['complete']
response = {
"meta": self.meta,
# "message": f"no data found for test id {student_id}",
"status": "success",
"stats": stats
}
return response, self.success_code, self.headers
else:
response = {
"meta": self.meta,
"message":
f"no data found for student with id {student_id}",
"status": "failure"
}
return response, self.no_data_code, self.headers
except Exception as e:
# raise e
response = {
"meta": self.meta,
"message": "unable to process request",
"status": "failure",
"reason": str(e)
}
return response, self.exception_code, self.headers
def get(self, **kwargs):
'''
'''
try:
args_data = request.args.to_dict()
print(args_data)
testid = args_data.get("testid", "all")
pageno = int(args_data.get("pageno", 1))
room_name = args_data.get('room_name')
cols = args_data.get('cols')
teacher_id = kwargs.get("_id")
collection1 = 'common_test_master'
collection2 = 'common_question_master'
if testid == "all":
if pageno > 1:
skip = 10 * (pageno - 1)
else:
skip = 0
columns1 = {"_id": 0}
queries1 = {"deleted": 0}
query_data1 = FlaskMongo.find(collection1, columns1, queries1)
total_count = len(query_data1)
print(f'total_count: {total_count}\n')
if cols:
columns = cols.split(',')
# print(f'\ncols: {cols}\n')
# print(f'\ncols: {dict((k, 0) for k in cols)}\n')
columns1 = {"_id": 0, "room_name": room_name}
columns1.update(dict((k, 1) for k in columns))
queries1 = {"deleted": 0, "teacher_id": teacher_id}
else:
columns = []
columns1 = {"_id": 0, "room_name": room_name}
queries1 = {"deleted": 0, "teacher_id": teacher_id}
query_data2 = FlaskMongo.find(collection1,
columns1,
queries1,
skip=skip,
limit=10)
data = {}
print(f'query_data2: {query_data2}\n')
if cols:
if len(columns) == 1:
select_column = columns[0]
print(f'select_column: {select_column}')
data = [d[select_column] for d in query_data2]
else:
data = query_data2
else:
for idx, qd1 in enumerate(query_data2):
columns3 = {"_id": 0}
queries3 = {"testid": qd1.get("id")}
query_data3 = FlaskMongo.find(collection2, columns3,
queries3)
# print(f'query_data3: {query_data3}\n')
# print(f'type: {type(query_data3)}\n')
details = []
for qd3 in query_data3:
qd1.update(qd3)
details.append(qd1)
data[idx] = details
total_pages = math.ceil(total_count / (10))
test_data = {
'total_count':
total_count,
'total':
total_pages,
'pageno':
pageno,
'previous':
pageno -
1 if pageno > 1 and pageno <= total_pages else None,
'next':
pageno + 1 if pageno < total_pages else None,
'data':
data
}
else:
queries1 = {"id": testid}
columns1 = {"_id": 0}
queries2 = {"testid": testid, "deleted": 0}
columns2 = {"customerid": 0, "testid": 0}
query_data1 = FlaskMongo.find(collection1, columns1, queries1)
query_data2 = FlaskMongo.find(collection2, columns2, queries2)
print(f'query_data1: {query_data1}\n')
print(f'query_data2: {query_data2}\n')
if query_data1 and query_data2:
query_data1 = query_data1[0]
query_data1['test_id'] = query_data1.pop('id')
query_data1['qna'] = query_data2
test_data = query_data1
else:
test_data = {}
response = {"meta": self.meta, "test_data": test_data}
FlaskLogger.log('get',
'tests_info',
response,
input_data=str(args_data),
log_level='info')
return response, self.success_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('get',
'tests_info',
response,
input_data=str(args_data),
log_level='warning')
return response, self.exception_code, self.headers
def get(self):
'''
'''
try:
args_data = request.args.to_dict()
test_id = args_data.get('testid')
collection1 = 'common_test_student_ques_answers'
collection2 = 'common_test_master'
columns = {'_id': 0}
queries1 = {'test_id': test_id}
query_data1 = FlaskMongo.find(collection1, columns, queries1)
queries2 = {'id': test_id}
query_data2 = FlaskMongo.find(collection2, columns, queries2)
if query_data1 and query_data2:
query_data2 = query_data2[0]
print(query_data2)
# query_data1 = query_data1[0]
# print(query_data1)
stats = {
'total': query_data2.get('no_mandatory_questions'),
'correct': 0,
'incorrect': 0,
'score': 0
}
for qd in query_data1:
if qd.get('is_correct'):
stats['correct'] = stats['correct'] + 1
stats['incorrect'] = stats['total'] - stats['correct']
stats['score'] = str(
round(stats['correct'] / stats['total'] * 100, 2)) + '%'
response = {
"meta": self.meta,
# "message": f"no data found for test id {test_id}",
"status": "success",
"stats": stats
}
return response, self.success_code, self.headers
else:
response = {
"meta": self.meta,
"message": f"no data found for test id {test_id}",
"status": "failure"
}
return response, self.no_data_code, self.headers
except Exception as e:
# raise 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):
"""
"""
try:
post_data = request.get_json()
# print(post_data)
testdeletion_data.load(post_data)
# Check for already exising entry:
collection1 = 'common_test_master'
collection2 = 'common_question_master'
test_id = post_data.get('test_id')
columns1 = {"_id": 0, "deleted": 0}
queries1 = {"id": test_id}
test_data = FlaskMongo.find(collection1, columns1, queries1)
if not test_data:
response = {
"meta": self.meta,
"message": f"test with id {test_id} does not exists",
"status": "failure"
}
FlaskLogger.log('delete',
'undo_del_tests',
response,
input_data=str(args_data),
log_level='info')
return response, self.bad_code, self.headers
else:
queries1 = {"id": test_id}
updates1 = {"deleted": 0}
FlaskMongo.update(collection1, updates1, queries1)
collection2 = 'common_question_master'
updates2 = {"deleted": 0}
queries2 = {"testid": test_id}
FlaskMongo.update(collection2, updates2, queries2)
response = {
"meta": self.meta,
"message":
f"test with id {test_id} undeleted successfully",
"status": "success"
}
FlaskLogger.log('delete',
'undo_del_tests',
response,
input_data=str(args_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('delete',
'undo_del_tests',
response,
input_data=str(args_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('delete',
'undo_del_tests',
response,
input_data=str(args_data),
log_level='warning')
return response, self.exception_code, self.headers
def get(self):
'''
'''
try:
args_data = request.args.to_dict()
test_id = args_data.get('testid')
db = c_app.config.get('MONGO_DATABASE')
collection1 = 'common_room_enroll_master'
columns = {'_id': 0}
queries = {}
aggregate_pipeline = [{
'$group': {
'_id': '$room_id',
'count': {
'$sum': 1
}
}
}]
room_counts = FlaskMongo.find(collection1,
columns,
queries,
aggregate=aggregate_pipeline)
# columns = {'_id': 0}
# queries = {}
# distinct_column = 'institute_name'
# institute_names = FlaskMongo.find(
# collection1, columns, queries, distinct=True, distinct_column=distinct_column
# )
total_rooms_enroll = db[collection1].find({}).count()
deleted_rooms_enroll = db[collection1].find({"deleted": 1}).count()
banned_rooms_enroll = db[collection1].find({
"banned": True
}).count()
rooms_enroll = {
'total': total_rooms_enroll,
'deleted': deleted_rooms_enroll,
'active': total_rooms_enroll - deleted_rooms_enroll,
'banned': banned_rooms_enroll,
'unbanned': total_rooms_enroll - banned_rooms_enroll
}
columns = {'room_id': 1}
queries = {}
rooms_ids = FlaskMongo.find(collection1, columns, queries)
rooms_ids = [rid.get('_id') for rid in rooms_ids]
columns = {'_id': 0, 'room_id': 1, 'limit': 1}
queries = {}
rooms_limits = FlaskMongo.find(collection1, columns, queries)
rooms_limits = [rid for rid in rooms_limits]
columns = {'_id': 0, 'room_id': 1, 'limit': 1}
queries = {}
rooms_enroll_counts = FlaskMongo.find(collection1, columns,
queries)
columns = {'_id': 0, 'room_id': 1, 'student_id': 1, 'created': 1}
queries = {}
rooms_enrollments = FlaskMongo.find(collection1, columns, queries)
stats = {
# 'rooms_ids': rooms_ids,
'rooms_enroll': rooms_enroll,
'rooms_enrollments': rooms_enrollments,
# 'rooms_limits': rooms_limits
# 'institute_names': institute_names
}
response = {"meta": self.meta, "status": "success", "stats": stats}
return response, self.success_code, self.headers
except Exception as e:
# raise e
response = {
"meta": self.meta,
"message": "unable to process request",
"status": "failure",
"reason": str(e)
}
return response, self.exception_code, self.headers
