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
})
