def close_other_logbooks(self): curr_user = self.get_current_flask_user() query_ref = db1.collection(u'logbooks').where('user_email', '==', curr_user) docs = query_ref.get() for doc in docs: doc_tmp = {} doc_tmp = doc.to_dict() log_status = doc_tmp['logStatus'] if log_status == 'activated' : doc_ref = db1.collection(u'logbooks').document(doc_tmp['log_uid']) doc_ref.update({ 'logStatus' : "expired" })
def get_current_active_logbook(self): curr_user = self.get_current_flask_user() query_ref = db1.collection(u'logbooks').where('user_email', '==', curr_user).where('logStatus', '==', 'activated') docs = query_ref.get() for doc in docs: return doc.to_dict() return None
def add_record(self, record_data): records_ref = db1.collection(u'records').document() DLP_list = record_data.get("DLP") Date_list = record_data.get("Date") Facility_list = record_data.get("Facility") Doctor_list = record_data.get("Co-reporting Doctor") UID_list = record_data.get("Unique Episode Number") upload_datetime = datetime.now() log_uid = self.get_current_active_logbook_id() #print(upload_datetime) Doctor_string = "" for doctor in Doctor_list: Doctor_string = Doctor_string + doctor + " ," records_ref.set({ 'user_email': self.get_current_flask_user(), 'DLP': DLP_list[0], 'record_date': Date_list[0], 'facility': Facility_list[0], 'co_reporting_doctor': Doctor_string, 'patient_details': UID_list[0], 'case_type': None, 'is_correlated': None, 'is_graft_thoracic_aorta': None, 'log_uid': log_uid, 'program_uid': None, 'record_status': None, 'supervisor_uid': None, 'upload_time': upload_datetime, 'current_certification': None, 'record_uid': records_ref.id }) doc = records_ref.get() return doc.to_dict()
def get_current_user_logbook_by_logname(self, log_name): if log_name == "": log = self.get_current_active_logbook() log_name = log['log_name'] curr_user = self.get_current_flask_user() query_ref = db1.collection(u'logbooks').where('user_email', '==', curr_user).where('log_name', '==', log_name) docs = query_ref.get() log_details = [] for doc in docs: tmp = {} # print(u'current user logbooks : {}'.format(doc.to_dict())) tmp = doc.to_dict() tmp_name = tmp['log_name'] if(log_name == tmp_name): log_details.append("log_name+" + log_name) log_details.append("log_uid+" + tmp['log_uid']) log_details.append("total_case_count+" + str(tmp['total_case_count'])) log_details.append("native_coronary_count+" + str(tmp['native_coronary_count'])) log_details.append("non_coronary_count+" + str(tmp['non_coronary_count'])) log_details.append("non_cardiac_count+" + str(tmp['non_cardiac_count'])) log_details.append("cardiac_count+" + str(tmp['cardiac_count'])) log_details.append("gta_count+" + str(tmp['gta_count'])) log_details.append("log_status+" + tmp['logStatus']) log_details.append("live_case_course_count+" + str(tmp['live_case_course_count'])) log_details.append("live_case_count+" + str(tmp['live_case_count'])) log_details.append("library_case_count" + str(tmp['library_case_count'])) log_details.append("created_time+" + str(tmp['created_time'])) log_details.append("correlated_case_count+" + str(tmp['correlated_case_count'])) return log_details return None
def get_record_dict_by_name(self, record_name): doc_ref = db1.collection(u'records').where('record_name','==',record_name) tmps = doc_ref.get() # print(u'Document data: {}'.format(doc.to_dict())) for tmp in tmps: docs = tmp.to_dict() return docs
def get_verify_token(self): curr_user = self.get_current_flask_user() doc_ref = db1.collection(u'users').document(curr_user) doc = doc_ref.get() tmp = doc.to_dict() print(tmp) return tmp['verify_token']
def delete_record(self, record_name): print(record_name) record_uid = self.get_record_id_by_name(record_name) doc_ref = db1.collection(u'records').document(record_uid) doc_ref.update({ u'record_status': 'deleted' })
def get_logbook_incomplete_count(self, log_uid): query_ref = db1.collection(u'records').where('log_uid', '==', log_uid).where('record_status', '==', 'incomplete') docs = query_ref.get() count = 0 for doc in docs: count = count +1 return count
def add_user_profile(self, user_data): print('add_user_profile_function entered') print(self.get_current_flask_user()) print(user_data) first_name = user_data['first_name'], last_name = user_data['last_name'], address_city = user_data['address_city'], address_country = user_data['address_country'], address = user_data['address'], address_postcode = user_data['address_postcode'], print(first_name[0] + ',' + last_name[0]) print(address[0] + ',' + address_city[0] + ',' + address_country[0] + ',' + address_postcode[0]) users_ref = db1.collection(u'users').document( self.get_current_flask_user()) users_ref.set({ u'first_name': first_name[0], u'last_name': last_name[0], u'is_supervisor': None, u'specialist_level': None, u'address_city': address_city[0], u'address_country': address_country[0], u'address': address[0], u'address_postcode': address_postcode[0], u'current_certification': None, u'current_cert_expiry_day': None, u'current_cert_expiry_month': None, u'current_cert_expiry_year': None, u'program_uid': None })
def get_user_details(self): curr_user = self.get_current_flask_user() print(curr_user) doc_ref = db1.collection(u'users').document(curr_user) doc = doc_ref.get() print('USER DETAILS !!!!!!!!!!!!!') print(u'Document data: {}'.format(doc.to_dict())) return doc.to_dict()
def get_records_by_logbook(self, log_id): query_ref = db1.collection(u'records').where('log_uid', '==', log_id) docs = query_ref.get() dicts_list = [] for doc in docs: print(u'Document data: {}'.format(doc.to_dict())) dicts_list.append(doc.to_dict) return dicts_list
def approve_report (self, record_name): supervisor_uid = self.get_current_flask_user() record_id = self.get_record_id_by_name(record_name) record_ref = db1.collection('records').document(record_id) record_ref.update({ u'supervisor_that_approved' :supervisor_uid, u'is_approved' : True })
def get_current_user_records_all(self): curr_user = self.get_current_flask_user() query_ref = db1.collection(u'records').where('user_email', '==', curr_user) docs = query_ref.get() dicts_list = [] for doc in docs: print(u'Document data: {}'.format(doc.to_dict())) dicts_list.append(doc.to_dict) return dicts_list
def get_current_active_logbook_name(self): curr_user = self.get_current_flask_user() query_ref = db1.collection(u'logbooks').where('user_email', '==', curr_user).where('logStatus', '==', 'activated') docs = query_ref.get() for doc in docs: log=doc.to_dict() if(log['logStatus'] == "activated"): return log['log_name'] return None
def check_if_supervisor(self, username): user_ref = db1.collection('users').document(username) doc=user_ref.get() tmp = doc.to_dict() print(tmp['supervisor_approved'] ) if tmp['supervisor_approved'] == True : return True else : return False return False
def get_record_list_by_name(self, record_name): doc_ref = db1.collection(u'records').where('record_name','==',record_name) tmps = doc_ref.get() # print(u'Document data: {}'.format(doc.to_dict())) # record_deet = [] for tmp in tmps: doc = tmp.to_dict() return doc # for key in sorted(docs.keys()): # record_deet.append(str(key) + "+" + str(docs[key])) return None
def get_record_by_name(self, record_name): doc_ref = db1.collection(u'records').where('record_name','==',record_name) docs = doc_ref.get() for doc in docs: print(u'Document data: {}'.format(doc.to_dict())) record_deet = [] tmps = doc.to_dict() for tmp in tmps: tmp_string = str(tmp) + "+" + str(tmps[tmp]) record_deet.append(tmp_string) return record_deet
def get_current_incomplete_records(self): curr_user = self.get_current_flask_user() active_logbook = self.get_current_active_logbook_id() # print(active_logbook) query_ref = db1.collection(u'records').where('user_email', '==', curr_user).where('log_uid', '==', active_logbook).where('record_status', '==', "incomplete") docs = query_ref.get() dicts_list = [] for doc in docs: tmp = doc.to_dict() # print(u'Document data: {}'.format(doc.to_dict())) dicts_list.append(str(tmp['record_name']) + '+' + str(tmp['upload_time'])) return dicts_list
def get_records_by_logbook(self, log_id): query_ref = db1.collection(u'records').where('log_uid', '==', log_id) docs = query_ref.get() dicts_list = [] for doc in docs: print(u'Get Records By Logbook data: {}'.format(doc.to_dict())) tmp = {} tmp = doc.to_dict() record_name = tmp['record_name'] record_date = tmp['upload_time'] dicts_list.append(record_name + '+' + str(record_date)) return dicts_list
def get_completed_levelA_records(self): records_ref = db1.collection('records').where('is_approved', '==', False) records = records_ref.get() record_list = [] for record in records: tmp = record.to_dict() if tmp['user_email'] != self.get_current_flask_user(): if tmp['record_status']=='Completed' or tmp['record_status']=='complete' : record_list.append(str(tmp['user_email']) + "+" + str(tmp['record_name']) + '+' + str(tmp['upload_time'])) return record_list
def check_unique_logbook(self, check_name): curr_user = self.get_current_flask_user() query_ref = db1.collection(u'logbooks').where('user_email', '==', curr_user) docs = query_ref.get() for doc in docs: doc_tmp = {} doc_tmp = doc.to_dict() log_name = doc_tmp['log_name'] if log_name == check_name : print ('check_unique_logbook failed: -------------' + check_name) return True print ('check_unique_logbook passed-----------' + check_name) return False
def get_logid_by_logname(self, log_name): curr_user = self.get_current_flask_user() query_ref = db1.collection(u'logbooks').where('user_email', '==', curr_user) docs = query_ref.get() log_details = [] for doc in docs: tmp = {} # print(u'current user logbooks : {}'.format(doc.to_dict())) tmp = doc.to_dict() tmp_name = tmp['log_name'] if(log_name == tmp_name): return tmp['log_uid'] return None
def view_all_supervisors(self): users_ref = db1.collection(u'users') docs = users_ref.get() supervisors = [] for doc in docs: tmp = doc.to_dict() if tmp['is_supervisor'] == True or tmp['is_supervisor'] == "True": username = tmp['user_email'] approved = tmp['supervisor_approved'] current_cert = tmp['current_certification'] current_cert_expiry = tmp['current_cert_expiry_date'] supervisors.append(str(username)+ "+" + str(approved) + "+" + str(current_cert)+ "+" +str(current_cert_expiry)) return supervisors
def get_current_user_incomplete_records(self): curr_user = self.get_current_flask_user() active_logbook = self.get_current_active_logbook_id() query_ref = db1.collection(u'records').where( 'user_email', '==', curr_user).where('log_uid', '==', active_logbook).where('is_correlated', '==', None) docs = query_ref.get() dicts_list = [] for doc in docs: print(u'Document data: {}'.format(doc.to_dict())) dicts_list.append(doc.to_dict) return dicts_list
def get_current_user_logbooks(self): curr_user = self.get_current_flask_user() query_ref = db1.collection(u'logbooks').where('user_email', '==', curr_user) docs = query_ref.get() log_list = [] for doc in docs: tmp = {} # print(u'current user logbooks : {}'.format(doc.to_dict())) tmp = doc.to_dict() log_name = tmp['log_name'] log_status = tmp['logStatus'] log_string = log_name + "+" + log_status log_list.append(log_string) return log_list
def update_user_profile(self, user_data): print('_user_profile_function entered') print(self.get_current_flask_user()) # user_data = self.check_user_details(user_details) print(user_data) print(user_data['first_name']) first_name = user_data['first_name'] last_name = user_data['last_name'] address_city = user_data['address_city'] address_country = user_data['address_country'] address_state = user_data['address_state'] address = user_data['address'] address_postcode = user_data['address_postcode'] current_cert_expiry_date = user_data['current_cert_expiry_date'] current_cert = user_data['current_cert'] if first_name == "" or last_name == "" or current_cert_expiry_date=="" or current_cert == "empty": return if address_city == "" or address == ""or address_country == "" or address_state == "" or address_postcode == "": return if current_cert == 'Level B': is_supervisor = True specialist_level = 'level_b' elif current_cert == 'Level A': specialist_level = 'level_a' is_supervisor = False else : specialist_level = 'Student' is_supervisor = False # print(first_name[0] + ',' + last_name [0]) # print(address[0] + ',' + address_city[0]+','+address_country[0] +','+address_postcode[0]) users_ref = db1.collection(u'users').document(self.get_current_flask_user()) users_ref.update({ u'first_name': first_name, u'last_name': last_name, u'is_supervisor': is_supervisor, u'specialist_level': specialist_level, u'address_city': address_city, u'address_country': address_country, u'address_state':address_state, u'address': address, u'address_postcode': address_postcode, u'current_certification': current_cert, u'current_cert_expiry_date': current_cert_expiry_date, u'program_uid': None })
def create_logbook(self, log_data): log_name = log_data['log_name'] program_tmp = log_data['current_cert'] if log_name == "" or program_tmp == "empty": return if self.check_unique_logbook(log_name) == True: return self.close_other_logbooks() logbooks_ref = db1.collection(u'logbooks').document() upload_datetime = datetime.now() program_uid = "no_program" if program_tmp == "Level A Certification": program_uid = "level_a_certification" elif program_tmp == "Level B Certification": program_uid = "level_b_certification" elif program_tmp == "Level A Recertification": program_uid = "level_a_recertification" elif program_tmp == "Level B Recertification": program_uid = "level_b_recertification" elif program_tmp == "Conversion from A to B": program_uid = "level_a_to_b_conversion" logbooks_ref.set({ 'user_email': self.get_current_flask_user(), 'total_case_count':0, 'program_uid': program_uid, 'non_coronary_count':0 , 'non_cardiac_count': 0, 'cardiac_count': 0, 'gta_count': 0, 'native_coronary_count': 0, 'logStatus' : "activated", 'live_case_course_count' : 0, 'live_case_count' :0, 'library_case_count':0, 'log_uid' : logbooks_ref.id, 'created_time' : upload_datetime, 'log_name' : log_name, 'correlated_case_count' :0 })
def create_admin_documents(self, user_id): users_ref = db1.collection(u'users').document(user_id) users_ref.set({ u'user_email': user_id, u'messenger_uid':None, u'verify_token':self.id_generator(), u'first_name': "", u'last_name': "", u'is_supervisor': True, u'specialist_level': "", u'address_city': "", u'address_country': "", u'address': "", u'address_state': "", u'address_postcode': "", u'current_certification': "", u'current_cert_expiry_date': "", u'program_uid': "", u'supervisor_approved':True }) self.create_default_logbook(user_id)
def write_to_csv(self, log_id): # log_id = self.get_current_active_logbook_id() query_ref = db1.collection(u'records').where('log_uid', '==', log_id) docs = query_ref.get() file_dict = {} log_details = self.get_current_active_logbook() file_dict['logbook_details'] = log_details count = 0 for doc in docs: tmps = doc.to_dict() tmp_dict = {} for key in sorted(tmps.keys()): tmp_dict[key] = tmps[key] file_dict["record " + str(count)] = tmp_dict count = count +1 # df = pandas.DataFrame(file_dict) # df.to_csv("output.csv") w = csv.writer(open(os.path.join(config.DATA_DIR, "output.csv"), "w")) for key, val in file_dict.items(): w.writerow([key, val])
def create_default_logbook(self, username): log_name = "Default" upload_datetime = datetime.now() logbooks_ref = db1.collection(u'logbooks').document() logbooks_ref.set({ 'user_email': username, 'total_case_count':0, 'program_uid': None, 'non_coronary_count':0 , 'non_cardiac_count': 0, 'cardiac_count': 0, 'gta_count': 0, 'native_coronary_count': 0, 'logStatus' : "activated", 'live_case_course_count' : 0, 'live_case_count' :0, 'library_case_count':0, 'log_uid' : logbooks_ref.id, 'created_time' : upload_datetime, 'log_name' : log_name, 'correlated_case_count' :0 })