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() 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 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 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 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 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 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 create_app(config_name): app = Flask(__name__, template_folder='../templates/', static_folder='../static') CORS(app) app.config.update(get_config(config_name)) # App Binding: from bindings.flask_mongo import FlaskMongo from bindings.flask_logger import FlaskLogger mongo_app = FlaskMongo() mongo_app.init_app(app) log_app = FlaskLogger() log_app.init_app(app) api = Api(app, catch_all_404s=True) # api = Api() # print(app.config.keys()) # Add API Routes: from routes.welcome import Welcome from routes.auth import Auth from routes.subscription import ResetTrial from routes.teacher import TeacherUsers from routes.student import StudentUsers from routes.admin import AdminUsers from routes.test import TestQuestionDetails, UnDeleteTest from routes.testattempt import TestAttemptDetails, TestAttemptComplete from routes.stat import TestScoresStats, StudentsStats from routes.rooms import RoomsApi from routes.rooms_enrolled import RoomsEnrolled from routes.stats.users import UsersStats from routes.stats.tests import TestsStats from routes.stats.rooms import RoomsStats from routes.stats.rooms_enrolled import RoomsEnrolledStats from routes.reports.creator import ReportsCreator from routes.mails.mailer import EmailsCreator api.add_resource(ReportsCreator, '/edu/v1/utils/pdfs/create', methods=['POST'], endpoint='g_pdf') api.add_resource(EmailsCreator, '/edu/v1/utils/mails/create', methods=['POST'], endpoint='g_mail') api.add_resource(UsersStats, '/edu/v1/stats/users/get', methods=['GET'], endpoint='get_ustats') api.add_resource(TestsStats, '/edu/v1/stats/tests/get', methods=['GET'], endpoint='get_tstats') api.add_resource(RoomsStats, '/edu/v1/stats/rooms/get', methods=['GET'], endpoint='get_rstats') api.add_resource(RoomsEnrolledStats, '/edu/v1/stats/rooms-enroll/get', methods=['GET'], endpoint='get_restats') api.add_resource(Welcome, '/edu/v1/api/welcome', methods=['GET'], endpoint='welcome_api') api.add_resource(Auth, '/edu/v1/api/login', methods=['POST'], endpoint='generate_token') api.add_resource(ResetTrial, '/edu/v1/users/reset-trial', methods=['POST'], endpoint='reset_trial') api.add_resource(TeacherUsers, '/edu/v1/users/teacher/get-user', methods=['GET'], endpoint='get_tuser') api.add_resource(TeacherUsers, '/edu/v1/users/teacher/add-user', methods=['POST'], endpoint='add_tuser') api.add_resource(TeacherUsers, '/edu/v1/users/teacher/mod-user', methods=['PUT'], endpoint='mod_tuser') api.add_resource(TeacherUsers, '/edu/v1/users/teacher/del-user', methods=['DELETE'], endpoint='del_tuser') api.add_resource(StudentUsers, '/edu/v1/users/student/get-user', methods=['GET'], endpoint='get_suser') api.add_resource(StudentUsers, '/edu/v1/users/student/add-user', methods=['POST'], endpoint='add_suser') api.add_resource(StudentUsers, '/edu/v1/users/student/mod-user', methods=['PUT'], endpoint='mod_suser') api.add_resource(StudentUsers, '/edu/v1/users/student/del-user', methods=['DELETE'], endpoint='del_suser') api.add_resource(AdminUsers, '/edu/v1/users/admin/get-user', methods=['GET'], endpoint='get_auser') api.add_resource(AdminUsers, '/edu/v1/users/admin/add-user', methods=['POST'], endpoint='add_auser') api.add_resource(AdminUsers, '/edu/v1/users/admin/mod-user', methods=['PUT'], endpoint='mod_auser') api.add_resource(AdminUsers, '/edu/v1/users/admin/del-user', methods=['DELETE'], endpoint='del_auser') api.add_resource(TestQuestionDetails, '/edu/v1/tests/get-test', methods=['GET'], endpoint='get_test') api.add_resource(TestQuestionDetails, '/edu/v1/tests/create-test', methods=['POST'], endpoint='add_test') api.add_resource(TestQuestionDetails, '/edu/v1/tests/mod-test', methods=['PUT'], endpoint='mod_test') api.add_resource(TestQuestionDetails, '/edu/v1/tests/del-test', methods=['DELETE'], endpoint='del_test') api.add_resource(UnDeleteTest, '/edu/v1/tests/undo-test-delete', methods=['POST'], endpoint='undo_test') api.add_resource(TestAttemptDetails, '/edu/v1/testattempts/create-test', methods=['POST'], endpoint='create_testa') api.add_resource(TestAttemptDetails, '/edu/v1/testattempts/mod-test', methods=['PUT'], endpoint='mod_testa') api.add_resource(TestAttemptComplete, '/edu/v1/testcomplete/mod-test', methods=['PUT'], endpoint='mod_testc') api.add_resource(TestScoresStats, '/edu/v1/teststats/get-test', methods=['GET'], endpoint='get_test_stats') api.add_resource(StudentsStats, '/edu/v1/studentstats/get-test', methods=['GET'], endpoint='get_stu_stats') api.add_resource(RoomsApi, '/edu/v1/rooms/create-room', methods=['POST'], endpoint='add_room') api.add_resource(RoomsApi, '/edu/v1/rooms/get-room', methods=['GET'], endpoint='get_room') api.add_resource(RoomsApi, '/edu/v1/rooms/mod-room', methods=['PUT'], endpoint='mod_room') api.add_resource(RoomsApi, '/edu/v1/rooms/del-room', methods=['DELETE'], endpoint='del_room') api.add_resource(RoomsEnrolled, '/edu/v1/rooms/create-room-enroll', methods=['POST'], endpoint='add_room_enroll') api.add_resource(RoomsEnrolled, '/edu/v1/rooms/get-room-enroll', methods=['GET'], endpoint='get_room_enroll') api.add_resource(RoomsEnrolled, '/edu/v1/rooms/mod-room-enroll', methods=['PUT'], endpoint='mod_room_enroll') api.add_resource(RoomsEnrolled, '/edu/v1/rooms/del-room-enroll', methods=['DELETE'], endpoint='del_room_enroll') return app
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