def test_doctor():
error = 0
print "begin doctor test\n"
body_config, food_config, empty_food_config, doctor_config = create_test_config(
)
food = Food(**food_config)
for key, value in empty_food_config.items():
check_minVit_config = food_config.copy()
if key[:3] == 'vit':
check_minVit_config[key] = value
body = Body(**body_config)
diseas = Diseas(symtom='symtom' + key[-1].upper(),
attackpoint=key,
name='diseas' + key[-1].lower())
doctor = Doctor(lambda x: x['illness'], **doctor_config)
body.eat(Food(**check_minVit_config))
print 'want to inflect at', key
diseas.attack(body)
print 'Now i am inflected'
if doctor.diagnose(body).lower() != 'diseas' + key[-1].lower():
error += 1
print "[ inflect wrong target"
body.eat(food)
print "i get cure "
if doctor.diagnose(body) != "Null":
error += 1
print "not get cure"
print "\n"
print "finish doctor test with error: ????", error
def guardar(self):
if self.doctor_user.id is None or self.doctor_user.id == 0:
self.doctor_user = Doctor()
self.doctor_user.username = self.txt_username.text()
self.doctor_user.nombres = self.txt_nombre.text()
self.doctor_user.apellidos = self.txt_apellido.text()
self.doctor_user.telefono = self.txt_telefono.text()
self.doctor_user.password = self.txt_password.text()
self.doctor_user.cedula = self.txt_cedula.text()
self.doctor_user.direccion = self.txt_direccion.text()
self.doctor_user.mail = self.txt_mail.text()
if(self.doctor_user.guardar()):
self.txt_username.setText('')
self.txt_nombre.setText('')
self.txt_apellido.setText('')
self.txt_telefono.setText('')
self.txt_password.setText('')
self.txt_cedula.setText('')
self.txt_direccion.setText('')
self.txt_mail.setText('')
self.doctor_user = Doctor()
QtWidgets.QMessageBox.information(self, '¡Enhorabuena!', 'Se ha registrado el doctor', QtWidgets.QMessageBox.Ok)
else:
QtWidgets.QMessageBox.warning(self, 'Error', 'Revisa los datos', QtWidgets.QMessageBox.Ok)
self.actualizarGrids()
def add_appointment_details(doc_avail, pat_avail):
data = json.load("Appointment.json", "r")
doctor_obj = Doctor()
patient_obj = Patient()
appointment_doctor = Appointment()
appointment_doctor.set_doctor(doc_avail)
appointment_doctor.set_patient(pat_avail)
now = datetime.now()
appointment_doctor.set_date(str(now)[:10])
try:
data["appointment"].append({
'doctor': appointment_doctor.get_doctor(),
'patient': appointment_doctor.get_patient(),
'date': appointment_doctor.get_date()
})
with open('Appointment.json', 'w') as database1:
json.dump(data, database1, sort_keys=True)
print("Details added successfully")
except Exception:
print("Data is not proper")
def addAppointmentDetails(doctordetail, patientdetail):
data = json.load(open('Appoinment.json', 'r'))
# data = {"appointment":[]}
# data["appoinment"] = {}
doctor_obj = Doctor()
patient_obj = Patient()
appointment_json = Appointment()
appointment_json.set_doctor(doctordetail)
appointment_json.set_patient(patientdetail)
now = datetime.now()
appointment_json.set_date(str(now)[:10])
try:
data["appointment"].append(
{'doctor': appointment_json.get_doctor(), 'patient': appointment_json.get_patient(),
'date': appointment_json.get_date()})
with open('Appoinment.json', 'w') as data1:
json.dump(data, data1, sort_keys=True)
print ("Person Detail Added Successfully!")
except (NameError, SyntaxError, TypeError):
print "Please enter a proper formated data only !"
def addDoctors():
list = client.getDoctors(msg['id'])
for i in range(len(list)):
d = list[i]
doctor.append(
Doctor.Doctor(d['id'], d['fisrtname'], d['lastname'],
data0, d['specjalizacja']))
def registerDoctor():
if client.isConnect(HOST, PORT):
if pas.get() == pasp.get():
if len(pas.get()) > 5:
client.sendRegisterDoctor(name2.get(), surname2.get(),
special2.get(), msg['name'],
msg['id'], login.get(),
pas.get())
re = client.isSucces()
if re:
doctor.append(
Doctor.Doctor(len(doctor), name2.get(),
surname2.get(), data0,
special2.get()))
docList.insert(tk.END,
name2.get() + " " + surname2.get())
setTextData(0, doctor)
var2.set("Rejsetracja powiodła się")
else:
var2.set("Doktor istnieje już w bazie danych")
else:
var2.set("Hasło musi mieć conajmniej 6 znaków")
else:
var2.set("Przepisz poprawnie hasło")
else:
var2.set("Nie można połączyć z serverem")
def eliminar(self):
try:
selected = self.tb_eliminar.selectedIndexes()
self.selected_index = selected.__getitem__(0)
select = self.todos[self.selected_index.row()]
doctor_user = Doctor()
doctor_user.id = select.id
rst=QMessageBox.warning(self,"Alerta","Esta seguro que desea eliminar", QMessageBox.Cancel, QMessageBox.Ok)
if rst == QMessageBox.Ok:
if(doctor_user.eliminar()):
QMessageBox.about(self,"¡Enhorabuena!", "Se ha eliminado al Doctor")
else:
print('dd')
QMessageBox.warning(self,"Error", "Ha ocurrido un error")
except:
QMessageBox.about(self,"Error", "Ha ocurrido un error")
self.actualizarGrids()
def elegir_dobleclick(self):
rst = QMessageBox.warning(self,"Alerta","¿Esta seguro que desea editar?", QMessageBox.Cancel, QMessageBox.Ok)
if rst != QMessageBox.Ok:
self.doctor_user = Doctor()
return
selected = self.tb_doctores.selectedIndexes()
self.selected_index = selected.__getitem__(0)
select = self.todos[self.selected_index.row()]
self.doctor_user.id = select.id
self.tabWidget.setCurrentWidget(self.tab_1)
self.txt_username.setText(select.username)
self.txt_nombre.setText(select.nombres)
self.txt_apellido.setText(select.apellidos)
self.txt_telefono.setText(select.telefono)
self.txt_password.setText(select.password)
self.txt_cedula.setText(select.cedula)
self.txt_direccion.setText(select.direccion)
self.txt_mail.setText(select.mail)
def parse_board(self, board_file):
"""
A function to parse a text-file containing the board and
populating the board-array with it
:param board_file: text file containing the board layout
:return: 2 dimensional array containing the tiles from the board file
"""
# Load all the data into the array
with open(board_file) as file:
board = [list(line.strip('\n')) for line in file]
# We make an iterator out of the board-list and go through it
# to check if all the rows are the same length
iterator = iter(board)
# set map_len to the length of the first row
map_len = len(next(iterator))
if not all(len(row) == map_len for row in iterator):
raise ValueError("All rows in map-file must be of equal length!")
# Replace characters with tiles and put entities into lists
for y in range(len(board)):
for x in range(len(board[y])):
if board[y][x] == ".":
board[y][x] = Tile(".")
elif board[y][x] == "#":
board[y][x] = Tile("#")
elif board[y][x] == "D":
dalek = Dalek.Dalek(x, y, self)
board[y][x] = Tile(".")
self.entities.append(dalek)
elif board[y][x] == "W":
doctor = Doctor.Doctor(x, y, self)
board[y][x] = Tile(".")
self.entities.append(doctor)
self.player = doctor
else:
raise ValueError(
"The only characters allowed in the map-file are\n . # D W"
)
return board
class VentanaDoctor(QDialog, doctor):
doctor_user = Doctor()
def __init__(self, parent = None):
QDialog.__init__(self, parent)
self.setupUi(self)
self.inicializar()
def inicializar(self):
self.btn_buscar.clicked.connect(self.buscar)
self.btn_guardar.clicked.connect(self.guardar)
self.btn_eliminar_todo.clicked.connect(self.eliminar)
self.todos = self.doctor_user.consultar_todos()
self.tb_doctores.doubleClicked.connect(self.elegir_dobleclick)
self.actualizarGrids()
self.btn_cerrar.clicked.connect(self.closeEvent)
def close(self):
self.hide()
def actualizarGrids(self):
self.todos = self.doctor_user.consultar_todos()
self.fillDataGrid(self.todos, self.tb_doctores)
self.fillDataGrid(self.todos, self.tb_eliminar)
def elegir_dobleclick(self):
rst = QMessageBox.warning(self,"Alerta","¿Esta seguro que desea editar?", QMessageBox.Cancel, QMessageBox.Ok)
if rst != QMessageBox.Ok:
self.doctor_user = Doctor()
return
selected = self.tb_doctores.selectedIndexes()
self.selected_index = selected.__getitem__(0)
select = self.todos[self.selected_index.row()]
self.doctor_user.id = select.id
self.tabWidget.setCurrentWidget(self.tab_1)
self.txt_username.setText(select.username)
self.txt_nombre.setText(select.nombres)
self.txt_apellido.setText(select.apellidos)
self.txt_telefono.setText(select.telefono)
self.txt_password.setText(select.password)
self.txt_cedula.setText(select.cedula)
self.txt_direccion.setText(select.direccion)
self.txt_mail.setText(select.mail)
def guardar(self):
if self.doctor_user.id is None or self.doctor_user.id == 0:
self.doctor_user = Doctor()
self.doctor_user.username = self.txt_username.text()
self.doctor_user.nombres = self.txt_nombre.text()
self.doctor_user.apellidos = self.txt_apellido.text()
self.doctor_user.telefono = self.txt_telefono.text()
self.doctor_user.password = self.txt_password.text()
self.doctor_user.cedula = self.txt_cedula.text()
self.doctor_user.direccion = self.txt_direccion.text()
self.doctor_user.mail = self.txt_mail.text()
if(self.doctor_user.guardar()):
self.txt_username.setText('')
self.txt_nombre.setText('')
self.txt_apellido.setText('')
self.txt_telefono.setText('')
self.txt_password.setText('')
self.txt_cedula.setText('')
self.txt_direccion.setText('')
self.txt_mail.setText('')
self.doctor_user = Doctor()
QtWidgets.QMessageBox.information(self, '¡Enhorabuena!', 'Se ha registrado el doctor', QtWidgets.QMessageBox.Ok)
else:
QtWidgets.QMessageBox.warning(self, 'Error', 'Revisa los datos', QtWidgets.QMessageBox.Ok)
self.actualizarGrids()
def eliminar(self):
try:
selected = self.tb_eliminar.selectedIndexes()
self.selected_index = selected.__getitem__(0)
select = self.todos[self.selected_index.row()]
doctor_user = Doctor()
doctor_user.id = select.id
rst=QMessageBox.warning(self,"Alerta","Esta seguro que desea eliminar", QMessageBox.Cancel, QMessageBox.Ok)
if rst == QMessageBox.Ok:
if(doctor_user.eliminar()):
QMessageBox.about(self,"¡Enhorabuena!", "Se ha eliminado al Doctor")
else:
print('dd')
QMessageBox.warning(self,"Error", "Ha ocurrido un error")
except:
QMessageBox.about(self,"Error", "Ha ocurrido un error")
self.actualizarGrids()
def fillDataGrid(self, result, tb):
model = QStandardItemModel()
model.setColumnCount(len(self.doctor_user.headernames))
model.setHorizontalHeaderLabels(self.doctor_user.headernames)
doctors = []
for doctor_result in result:
li = [doctor_result.username, doctor_result.nombres, doctor_result.apellidos, doctor_result.telefono, doctor_result.cedula, doctor_result.direccion, doctor_result.mail]
doctors.append(li)
row = []
for name in li:
item = QStandardItem(str(name))
item.setEditable(False)
row.append(item)
model.appendRow(row)
tb.setModel(model)
return doctors
def buscar(self):
texto = self.txt_buscar.text()
if len(texto) < 1:
QMessageBox.about(self,"Error", "No encontramos nada")
self.actualizarGrids()
result = []
if self.radioButton_nombre.isChecked():
result = self.doctor_user.consultar_By_Atribute(texto, 'nombres')
elif self.radioButton_apellido.isChecked():
result = self.doctor_user.consultar_By_Atribute(texto, 'apellidos')
elif self.radioButton_cedula.isChecked():
result = self.doctor_user.consultar_By_Atribute(texto, 'cedula')
self.fillDataGrid(result, self.tb_doctores)
def closeEvent(self):
self.hide()
def add_doctor():
doctor_obj = Doctor()
data = {}
data["doctor"] = {}
data = json.load(open('Doctor.json', 'r'))
try:
first_name = raw_input("Enter first name: ")
doctor_obj.set_first_name(first_name)
last_name = raw_input("Enter last name: ")
doctor_obj.set_last_name(last_name)
id = raw_input("Enter Doctor Id : ")
doctor_obj.set_id(id)
specialization = raw_input("Enter doctor Specialization : ")
doctor_obj.set_specification(specialization)
availability = raw_input("Enter Doctor Availability : ")
doctor_obj.set_availability(availability)
data["doctor"][first_name] = ({
'first_name': doctor_obj.get_first_name(),
'last_name': doctor_obj.get_last_name(),
'id': doctor_obj.get_id(),
'specialization': doctor_obj.get_specification(),
'availability': doctor_obj.get_availability(),
})
with open('Doctor.json', 'w') as data1:
json.dump(data, data1,sort_keys=True)
print ("Person Detail Added Successfully!")
except (NameError, SyntaxError,TypeError):
print "Please enter a proper formated data only !"
def __init__(self, client, HOST, PORT):
global msg, doctor, data0
root = tk.Tk()
root.title("Recepcja")
root.geometry("1280x800+0+0")
root.configure(background="white")
doctor = []
data0 = []
msg = client.getMessageRec()
def guit():
cal.closeThread()
root.protocol("WM_DELETE_WINDOW", quit)
DocList = tk.Label(root, text="Lista Lekarzy:", bg="white").place(x=10,
y=10)
docList = tk.Listbox(root, width=50, height=4)
docList.pack()
docList.place(x=10, y=40)
scrl = tk.Scrollbar(root)
doctor.append(Doctor.Doctor(0, "Wszyscy", "Lekarze", "0", "-"))
def addDoctors():
list = client.getDoctors(msg['id'])
for i in range(len(list)):
d = list[i]
doctor.append(
Doctor.Doctor(d['id'], d['fisrtname'], d['lastname'],
data0, d['specjalizacja']))
addDoctors()
def addData():
pass
#pobieranie lekarzy
for doc in doctor:
docList.insert(tk.END, doc.name + " " + doc.surname)
scrl.place(in_=docList, relx=1, rely=0, relheight=1)
scrl.config(command=docList.yview)
Name = tk.Label(root, text="Imie", bg="white").place(x=10, y=140)
name = tk.Entry(root, width=25)
name.pack()
name.place(x=10, y=165)
Surname = tk.Label(root, text="Nazwisko", bg="white").place(x=180,
y=140)
surname = tk.Entry(root, width=25)
surname.pack()
surname.place(x=180, y=165)
Special = tk.Label(root, text="Specjalizacja", bg="white").place(x=10,
y=195)
special = tk.Entry(root, width=25)
special.pack()
special.place(x=10, y=220)
def clickList(self):
if len(docList.curselection()) > 0:
global x
x = docList.curselection()
name.delete(0, len(name.get()))
name.insert(0, doctor[x[len(x) - 1]].name)
surname.delete(0, len(surname.get()))
surname.insert(0, doctor[x[len(x) - 1]].surname)
special.delete(0, len(special.get()))
special.insert(0, doctor[x[len(x) - 1]].special)
if not x[len(x) - 1] == 0:
name4.delete(0, len(name4.get()))
name4.insert(0, doctor[x[len(x) - 1]].name)
surname4.delete(0, len(surname4.get()))
surname4.insert(0, doctor[x[len(x) - 1]].surname)
docList.bind('<<ListboxSelect>>', clickList)
var = tk.StringVar()
Info = tk.Label(root, textvariable=var, bg="white",
fg="red").place(x=10, y=250)
def clickBut():
try:
if client.isConnect(HOST, PORT):
#zmiana zmiennych lekarza
doctor[x[len(x) - 1]].name = name.get()
doctor[x[len(x) - 1]].surname = surname.get()
doctor[x[len(x) - 1]].special = special.get()
docList.delete(0, docList.size())
for doc in doctor:
docList.insert(tk.END, doc.name + " " + doc.surname)
client.sendChangeDoctor()
var.set("Zapisano Zmiany")
else:
var.set("Nie można połączyć z serverem")
except NameError:
var.set("Wybierz edytowanego użytkownika")
Log = tk.Button(root, text="Zmień", command=clickBut).place(width=100,
height=30,
x=190,
y=205)
Title = tk.Label(root, text="Terminarz:", bg="white").place(x=450,
y=10)
scrl2 = tk.Scrollbar(root)
textB = tk.Text(root,
width=50,
height=24,
highlightthickness=1,
bd=0,
highlightbackground="grey",
wrap="none")
textB.pack(expand=True)
textB.place(x=450, y=40)
scrl2.place(in_=textB, relx=1, rely=0, relheight=1)
textB.configure(state='disabled')
textB.config(cursor="arrow", yscrollcommand=scrl2.set)
scrl2.config(command=textB.yview)
def setTextB(text):
textB.configure(state='normal')
textB.delete('1.0', tk.END)
textB.insert(tk.END, text)
textB.configure(state='disabled')
# s = ""
# for i in range(100):
# s = s + "siema"+str(i)+"\n"
# setTextB(s)
def minutesString(n):
if n < 10:
return "0" + str(n)
else:
return str(n)
def getTextDoctor(id, l, day, month, year):
d = l[id]
s = d.name + " " + d.surname + ": \n"
if not d.data == data0:
if day == -1:
for j in range(len(d.data)):
s = s + " " + minutesString(
d.data[j].day
) + "." + minutesString(d.data[j].month) + "." + str(
d.data[j].year
) + " " + str(d.data[j].godzina) + ":" + minutesString(
d.data[j].minuta) + " - " + d.data[
j].name + " " + d.data[j].surname + "\n"
else:
for j in range(len(d.data)):
if day == d.data[j].day and month == d.data[
j].month and year == d.data[j].year:
s = s + " " + minutesString(d.data[j].day) + "." + minutesString(d.data[j].month) + "." + str(
d.data[j].year) + " " + str(
d.data[j].godzina) + ":" + minutesString(d.data[j].minuta) + " - " + d.data[j].name + " " + \
d.data[
j].surname + "\n"
return s
cal = CalendarGraph.CalendarGraph(root, 10, 380)
def setTextData(id, l):
saveday = cal.getSaveDay()
savemonth = cal.getSaveMonth()
saveyear = cal.getSaveYear()
s = ""
if id == 0:
for i in range(len(l) - 1):
s = s + getTextDoctor(i + 1, l, saveday, savemonth,
saveyear) + "\n"
else:
s = getTextDoctor(id, l, saveday, savemonth, saveyear)
setTextB(s)
def upgradeTermByCal(event):
global x
cal.save(event)
try:
setTextData(x[len(x) - 1], doctor)
except NameError:
setTextData(0, doctor)
setTextData(0, doctor)
root.bind("<Button-1>", upgradeTermByCal)
Login = tk.Label(root, text="Login nowego lekarza:",
bg="white").place(x=890, y=10)
login = tk.Entry(root, width=50)
login.pack()
login.place(x=890, y=40)
Pas = tk.Label(root, text="Hasło:", bg="white").place(x=890, y=80)
pas = tk.Entry(root, width=50, show="*")
pas.pack()
pas.place(x=890, y=110)
Pasp = tk.Label(root, text="Powtórz Hasło:", bg="white").place(x=890,
y=150)
pasp = tk.Entry(root, width=50, show="*")
pasp.pack()
pasp.place(x=890, y=180)
Name2 = tk.Label(root, text="Imie:", bg="white").place(x=890, y=220)
name2 = tk.Entry(root, width=50)
name2.pack()
name2.place(x=890, y=250)
Surname2 = tk.Label(root, text="Nazwisko:", bg="white").place(x=890,
y=290)
surname2 = tk.Entry(root, width=50)
surname2.pack()
surname2.place(x=890, y=320)
Special2 = tk.Label(root, text="Specjalizacja:",
bg="white").place(x=890, y=360)
special2 = tk.Entry(root, width=50)
special2.pack()
special2.place(x=890, y=390)
var2 = tk.StringVar()
Info2 = tk.Label(root, textvariable=var2, bg="white",
fg="red").place(x=890, y=420)
def registerDoctor():
if client.isConnect(HOST, PORT):
if pas.get() == pasp.get():
if len(pas.get()) > 5:
client.sendRegisterDoctor(name2.get(), surname2.get(),
special2.get(), msg['name'],
msg['id'], login.get(),
pas.get())
re = client.isSucces()
if re:
doctor.append(
Doctor.Doctor(len(doctor), name2.get(),
surname2.get(), data0,
special2.get()))
docList.insert(tk.END,
name2.get() + " " + surname2.get())
setTextData(0, doctor)
var2.set("Rejsetracja powiodła się")
else:
var2.set("Doktor istnieje już w bazie danych")
else:
var2.set("Hasło musi mieć conajmniej 6 znaków")
else:
var2.set("Przepisz poprawnie hasło")
else:
var2.set("Nie można połączyć z serverem")
Reg = tk.Button(root, text="Zarejestruj",
command=registerDoctor).place(width=100,
height=30,
x=890,
y=450)
changeData = tk.Label(root, text="Zmień date wizyty",
bg="white").place(x=450, y=450)
changeData = tk.Label(
root,
text="Podaj starą date i godzine wizyty oraz dane pacjenta",
bg="white").place(x=450, y=470)
dayVar = tk.IntVar()
daySpin = tk.Spinbox(root,
from_=1,
to=31,
textvariable=dayVar,
width=6)
daySpin.pack()
daySpin.place(x=450, y=500)
monthVar = tk.IntVar()
monthSpin = tk.Spinbox(root,
from_=1,
to=12,
textvariable=monthVar,
width=6)
monthSpin.pack()
monthSpin.place(x=510, y=500)
yearVar = tk.IntVar()
yearSpin = tk.Spinbox(root,
from_=datetime.datetime.now().year,
to=datetime.datetime.now().year + 1000,
textvariable=yearVar,
width=6)
yearSpin.pack()
yearSpin.place(x=570, y=500)
hourVar = tk.IntVar()
hourSpin = tk.Spinbox(root,
from_=1,
to=24,
textvariable=hourVar,
width=6)
hourSpin.pack()
hourSpin.place(x=650, y=500)
minuteVar = tk.IntVar()
minuteSpin = tk.Spinbox(root,
from_=0,
to=60,
textvariable=minuteVar,
width=6)
minuteSpin.pack()
minuteSpin.place(x=710, y=500)
Name3 = tk.Label(root, text="Imie:", bg="white").place(x=450, y=520)
name3 = tk.Entry(root, width=20)
name3.pack()
name3.place(x=450, y=540)
Surname3 = tk.Label(root, text="Nazwisko:", bg="white").place(x=580,
y=520)
surname3 = tk.Entry(root, width=20)
surname3.pack()
surname3.place(x=580, y=540)
changeData = tk.Label(
root,
text="Podaj nową date i godzine wizyty oraz dane lekarza",
bg="white").place(x=450, y=570)
dayVarNew = tk.IntVar()
daySpinNew = tk.Spinbox(root,
from_=1,
to=31,
textvariable=dayVarNew,
width=6)
daySpinNew.pack()
daySpinNew.place(x=450, y=600)
monthVarNew = tk.IntVar()
monthSpinNew = tk.Spinbox(root,
from_=1,
to=12,
textvariable=monthVarNew,
width=6)
monthSpinNew.pack()
monthSpinNew.place(x=510, y=600)
yearVarNew = tk.IntVar()
yearSpinNew = tk.Spinbox(root,
from_=datetime.datetime.now().year,
to=datetime.datetime.now().year + 1000,
textvariable=yearVarNew,
width=6)
yearSpinNew.pack()
yearSpinNew.place(x=570, y=600)
hourVarNew = tk.IntVar()
hourSpinNew = tk.Spinbox(root,
from_=1,
to=24,
textvariable=hourVarNew,
width=6)
hourSpinNew.pack()
hourSpinNew.place(x=650, y=600)
minuteVarNew = tk.IntVar()
minuteSpinNew = tk.Spinbox(root,
from_=0,
to=60,
textvariable=minuteVarNew,
width=6)
minuteSpinNew.pack()
minuteSpinNew.place(x=710, y=600)
Name4 = tk.Label(root, text="Imie:", bg="white").place(x=450, y=620)
name4 = tk.Entry(root, width=20)
name4.pack()
name4.place(x=450, y=640)
Surname4 = tk.Label(root, text="Nazwisko:", bg="white").place(x=580,
y=620)
surname4 = tk.Entry(root, width=20)
surname4.pack()
surname4.place(x=580, y=640)
def lookForDoctor(lookName, lookSurname):
for i in range(len(doctor)):
if doctor[i].name == lookName and doctor[
i].surname == lookSurname:
return i
return -1
def lookForDoctorByName(lookName, lookSurname):
for i in range(len(doctor)):
for j in range(len(doctor[i].data)):
if doctor[i].data[j].name == lookName and doctor[i].data[
j].surname == lookSurname:
if doctor[i].data[j].day == dayVar.get(
) and doctor[i].data[j].month == monthVar.get(
) and doctor[i].data[j].year == yearVar.get():
if doctor[i].data[j].minuta == minuteVar.get(
) and doctor[i].data[j].godzina == hourVar.get():
return i
return -1
var3 = tk.StringVar()
Info3 = tk.Label(root, textvariable=var3, bg="white",
fg="red").place(x=450, y=680)
def changeD():
if client.isConnect(HOST, PORT):
if len(name3.get()) > 0 and len(name4.get()) > 0 and len(
surname3.get()) > 0 and len(surname4.get()) > 0:
if True:
indexDoc1 = lookForDoctorByName(
name3.get(), surname3.get())
go = False
if not indexDoc1 == -1:
go = True
indexDoc2 = lookForDoctor(name4.get(), surname4.get())
if (not lookForDoctor(name4.get(), surname4.get())
== -1) and go:
doctor[lookForDoctorByName(
name3.get(), surname3.get())].removeData(
dayVar.get(), monthVar.get(),
yearVar.get(), hourVar.get(),
minuteVar.get())
doctor[indexDoc2].data.append(
Data.Data(dayVarNew.get(), monthVarNew.get(),
yearVarNew.get(), name3.get(),
surname3.get(), hourVarNew.get(),
minuteVarNew.get()))
setTextData(0, doctor)
var3.set("Udało się zmienić")
else:
if go:
var3.set("Nie znaleziono lekarza")
else:
var3.set("Nie znaleziono terminu")
else:
var3.set("Uzupełnij wszystkie pola formularza")
else:
var3.set("Nie można połączyć z serverem")
Reg = tk.Button(root, text="Zmień", command=changeD).place(width=100,
height=30,
x=450,
y=710)
root.mainloop()
async def create(self, message, role_dictionary, players):
# Set guild
self.guild = message.guild
## Generate random players
random.seed(os.urandom(200))
for char_type, count in role_dictionary.items():
for i in range(0, count):
rand_player = random.randint(0, len(players) - 1)
print("{} : {}".format(char_type, message.guild.get_member(players[rand_player])))
if char_type == "Doctor":
self.players[players[rand_player]] = Doctor.Doctor(players[rand_player], message.guild.get_member(players[rand_player]).name)
elif char_type == "Mafia":
self.players[players[rand_player]] = Mafia.Mafia(players[rand_player], message.guild.get_member(players[rand_player]).name)
self.mafia[players[rand_player]] = self.players[players[rand_player]]
elif char_type == "Villager":
self.players[players[rand_player]] = Villager.Villager(players[rand_player], message.guild.get_member(players[rand_player]).name)
elif char_type == "Cop":
self.players[players[rand_player]] = Cop.Cop(players[rand_player], message.guild.get_member(players[rand_player]).name)
elif char_type == "TownCrier":
self.players[players[rand_player]] = TownCrier.TownCrier(players[rand_player], message.guild.get_member(players[rand_player]).name)
players.remove(players[rand_player])
self.game_composition = self.players.copy()
# Create roles
self.roles["Dead"] = await message.guild.create_role(name="Dead")
self.roles["Day"] = await message.guild.create_role(name="Day")
self.roles["Night"] = await message.guild.create_role(name="Night")
self.roles["Alive"] = await message.guild.create_role(name="Alive")
await self.roles["Dead"].edit(position=1, hoist=True)
await self.roles["Alive"].edit(position=1, hoist=True)
# Create permissions and channels
base_perms = { message.guild.default_role : discord.PermissionOverwrite(read_messages=False,send_messages=False) }
base_perms[self.roles["Dead"]] = discord.PermissionOverwrite(read_messages=True)
mafia_perms = base_perms.copy()
mafia_perms[self.roles["Alive"]] = discord.PermissionOverwrite(send_messages=True)
for player, val in self.mafia.items():
mafia_perms[message.guild.get_member(player)] = discord.PermissionOverwrite(read_messages=True)
mafia_channel = await message.guild.create_text_channel("mafia", overwrites=mafia_perms)
self.night_channels["mafia"].append(mafia_channel)
for player, val in self.mafia.items():
self.player_channels[player] = mafia_channel
villager_perms = base_perms.copy()
for player, val in self.players.items():
villager_perms[message.guild.get_member(player)] = discord.PermissionOverwrite(read_messages=True)
villager_perms[self.roles["Day"]] = discord.PermissionOverwrite(send_messages=True)
villager_perms[self.roles["Night"]] = discord.PermissionOverwrite(send_messages=False)
self.day_channels["townhall"].append(await message.guild.create_text_channel("townhall", overwrites=villager_perms))
dead_perms = base_perms.copy()
dead_perms[self.roles["Dead"]] = discord.PermissionOverwrite(read_messages=True,send_messages=True)
self.dead_channel = await message.guild.create_text_channel("Dead", overwrites=dead_perms)
for player, val in self.players.items():
if val.name == "Mafia":
continue
if val.can_act is True:
curr_perms = base_perms.copy()
curr_perms[message.guild.get_member(player)] = discord.PermissionOverwrite(read_messages=True)
if val.act_time == "Day":
curr_perms[self.roles["Day"]] = discord.PermissionOverwrite(send_messages=True)
player_channel = await message.guild.create_text_channel(val.name, overwrites=curr_perms)
self.day_channels[val.name].append(player_channel)
elif val.act_time == "Night":
curr_perms[self.roles["Night"]] = discord.PermissionOverwrite(send_messages=True)
player_channel = await message.guild.create_text_channel(val.name, overwrites=curr_perms)
self.night_channels[val.name].append(player_channel)
self.player_channels[player] = player_channel
for player_id, channel in self.player_channels.items():
await channel.send("{} You are a {}.\n{}".format(self.guild.get_member(player_id).mention, self.players[player_id].name, self.players[player_id].whoami()))
help_msg = (
"`!act <number>` - Act on <number\> if your role has the ability to `!act`.\n"
"`!abstain` - Abstain from lynching. If you already voted - removes your vote.\n"
"`!tovote` - Gets players who have not voted for lynching.\n"
"`!timer` - Vote to start a timer which forces a lynch in 1 minute.\n"
"`!gamecomp` - List dead players and the game composition.\n"
"`!list` - Lists players and their act numbers.\n"
"`!lastwill <message>` - Adds <message\> as your lastwill, to be displayed on death.\n"
)
await self.broadcast_message("townhall", help_msg)
await self.update()
'patient_prefix': patient_info[4],
'patient_surname': patient_info[5],
'doctors_phone_number': doctor_info[0],
'doctors_address1': doctor_info[1],
'doctors_address2': doctor_info[2],
'dr_name': doctor_info[3],
'day': appointment_info[0],
'month': appointment_info[1],
'year': appointment_info[2],
'time': appointment_info[3],
'clinic_type': appointment_info[4],
'signature': signature
}
save_path = "generated/" + patient_info[6] + patient_info[5] + ".docx"
tpl.render(context)
tpl.save(save_path)
if __name__ == "__main__":
doctorJB = Dr.Doctor("Backwell", "Gastroenterology",
["123 Street", "W1 456"], "0123456789",
"Guy's Hospital")
appointment1 = appt.Appointment("1st", "January", "2020", "12:00",
"Gastro Clinic",
"8f789d0b-3145-4cf2-8504-13159edaa747")
fhir = FHIR('https://localhost:5001/api/', verify_ssl=False)
patients = fhir.get_patient_page(5)
for patient in patients:
generateApptLetterDocX(patient.uuid, doctorJB, appointment1,
"templates/doctorAppointment.docx")
def getDoctor(url):
"""
This function takes an url from a Doctor page and grabs all the
needed data from there.
"""
#requesting the page and reading it
try:
page = request.urlopen(url).read()
except Exception as e:
#if some error occurs, it returns a void Doctor object
#(all attributes are setted as "---")
print(e)
return Doctor()
#taking the BS manager
soup = BS(page, "html.parser")
#FULL NAME : doctor_name: IS MANDATORY! If it is not possible
#to obtain the name, it raises an error to be treated in the main
#function
try:
#taking, from all list item '<li class="dropdown"></li>',
#the string of the last one
doctor_name = soup.find_all("li",
class_="dropdown")[-1].span.string #OK
except:
print("Couldn't get name.")
f = open(file_name_if_couldnt_get_doctor_name, "a")
f.write(url + "\n")
f.close()
raise Exception(
"\033[91;mCould not get a name. A void entry is returned as '---'.\033[m"
)
# SKILLS LIST : doctor_skills_list
try:
#taking, from all h2 title '<h2 class="h4"></h2>', the first entry
doctor_skills_h2 = soup.find_all("h2", class_="h4")[0]
#taking all the anchors <a> inside the <h2>
doctor_skills_a = doctor_skills_h2.find_all('a')
#list for appending
doctor_skills_list = []
for a in doctor_skills_a:
doctor_skills_list.append(a.string)
except:
#if it fails, take it as ["---"]
doctor_skills_list = ["---"]
print("Couldn't get doctor_skills_list.")
#SPECIALTY
try:
#taking, from all list item '<li class="dropdown"></li>', the second entry
#taking, from all anchors '<a itemprop="item"></a>', the first entry
#inside the <li> as string
doctor_specialty = soup.find_all("li", \
class_="dropdown")[1].find_all("a",\
itemprop="item")[0].span.string
except:
#if it fails, take it as "---"
doctor_specialty = "---"
print("Couldn't get specialty.")
# CITY
try:
#taking, from all list item '<li class="dropdown"></li>', the third entry
#taking, from all anchors '<a itemprop="item"></a>', the first entry
#inside the <li> as string
doctor_city = soup.find_all("li", \
class_="dropdown")[2].find_all("a", \
itemprop="item")[0].span.string
except:
#if it fails, take it as "---"
doctor_city = "---"
print("Couldn't get city.")
# STATE
try:
#taking,from all span, the content of the first entry
#'<span class="province region"></span>'
doctor_state = soup.find_all("span", \
class_="province region")[0]["content"]
except:
#if it fails, take it as "---"
doctor_state = "---"
print("Couldn't get state.")
# PHONE
try:
#taking, from all anchors '<a class="visible-xs"></a>', the second entry
#as string
doctor_phone = soup.find_all("a", class_="visible-xs")[1].string
except:
#if it fails, take it as "---"
doctor_phone = "---"
print("Couldn't get phone number.")
#building a Doctor object for returning
D = Doctor()
D.setName(doctor_name)
D.setSpecialty(doctor_specialty)
D.setSkills(", ".join(doctor_skills_list))
D.setState(doctor_state)
D.setCity(doctor_city)
D.setPhone(doctor_phone)
return D
def add_doc():
doc_obj = Doctor()
data = {}
data["doctor"] = {}
data = json.load("Doctor.json", "r")
try:
f_name = input("Enter the First Name")
doc_obj.set_first_name(f_name)
l_name = input("Enter the Last Name")
doc_obj.set_last_name(l_name)
id = input("Enter id")
if len(id) > 4:
print("Invalid Id")
exit(0)
else:
doc_obj.set_id(id)
specialization = input("Enter Specialization ")
doc_obj.set_specialization(specialization)
avail = input("Enter availability")
doc_obj.set_availability(avail)
data["doctor"][f_name] = ({
'f_name':
doc_obj.get_first_name(),
'l_name':
doc_obj.get_last_name(),
'id':
doc_obj.get_id(),
'specialization':
doc_obj.get_specialization(),
'avail':
doc_obj.get_availability()
})
with open('Doctor.json', 'w') as database1:
json.dump(data, database1, sort_keys="True")
print("Doctor Detail Added Successfully")
except (NameError, SyntaxError, TypeError):
print("Not a proper type of data")
def create(self, message, role_dictionary, players_list):
## Generate random players_list
random.seed(os.urandom(200))
for char_type, count in role_dictionary.items():
for i in range(0, count):
rand_player = random.randint(0, len(players_list) - 1)
print("{} : {}".format(char_type, message.guild.get_member(player_id)))
player_id = players_list[rand_player]
member_object = message.guild.get_member(player_id)
if char_type == "Doctor":
self.alive_players[player_id] = Doctor.Doctor(player_id, member_object.name)
elif char_type == "Mafia":
self.alive_players[player_id] = Mafia.Mafia(player_id, member_object.name)
self.mafia[player_id] = self.alive_players[player_id]
elif char_type == "Villager":
self.alive_players[player_id] = Villager.Villager(player_id, member_object.name)
elif char_type == "Cop":
self.alive_players[player_id] = Cop.Cop(player_id, member_object.name)
elif char_type == "TownCrier":
self.alive_players[player_id] = TownCrier.TownCrier(player_id, member_object.name)
self.player_to_member[player_id] = member_object
players_list.remove(player_id)
# Copy to game composition
self.game_comp = self.alive_players.copy()
# Create roles
self.roles["Dead"] = await message.guild.create_role(name="Dead")
self.roles["Day"] = await message.guild.create_role(name="Day")
self.roles["Night"] = await message.guild.create_role(name="Night")
self.roles["Alive"] = await message.guild.create_role(name="Alive")
await self.roles["Alive"].edit(position=1, hoist=True)
await self.roles["Dead"].edit(position=1, hoist=True)
# Create permissions and channels
# Create base permissions
base_perms = { message.guild.default_role : discord.PermissionOverwrite(read_messages=False,send_messages=False) }
base_perms[self.roles["Dead"]] = discord.PermissionOverwrite(read_messages=True)
# Mafia permissions
mafia_perms = base_perms.copy()
mafia_perms[self.roles["Alive"]] = discord.PermissionOverwrite(send_messages=True)
for player_id in self.mafia:
mafia_perms[message.guild.get_member(player_id)] = discord.PermissionOverwrite(read_messages=True)
self.mafia_channel = await message.guild.create_text_channel("mafia", overwrites=mafia_perms)
# Villager permissions
villager_perms = base_perms.copy()
for player_id in self.game_comp:
villager_perms[message.guild.get_member(player_id)] = discord.PermissionOverwrite(read_messages=True)
villager_perms[self.roles["Day"]] = discord.PermissionOverwrite(send_messages=True)
villager_perms[self.roles["Night"]] = discord.PermissionOverwrite(send_messages=False)
self.villager_channel = await message.guild.create_text_channel("townhall", overwrites=villager_perms)
dead_perms = base_perms.copy()
dead_perms[self.roles["Dead"]] = discord.PermissionOverwrite(read_messages=True,send_messages=True)
self.dead_channel = await message.guild.create_text_channel("Dead", overwrites=dead_perms)
# Individual role permissions
for player_id, role_class in self.game_comp.items():
if role_class.role_name == "mafia":
continue
# Zero out last will and act channel
last_will_channel = 0
act_channel = 0
# Setup a lastwill channel for every player
last_will_perms = base_perms.copy()
last_will_perms[message.guild.get_member(player_id)] = discord.PermissionOverwrite(read_messages=True)
last_will_perms[self.roles["Night"]] = discord.PermissionOverwrite(send_messages=True)
last_will_channel = await message.guild.create_text_channel("lastwill", overwrites=last_will_perms)
# Setup an act channel if appropriate
if role_class.can_act is True:
act_perms = base_perms.copy()
act_perms[message.guild.get_member(player_id)] = discord.PermissionOverwrite(read_messages=True)
act_perms[self.roles[role_class.act_time]] = discord.PermissionOverwrite(send_messages=True)
act_channel = await message.guild.create_text_channel(role_class.role_name, overwrites=act_perms)
self.player_channels[player_id] = PlayerChannels(last_will_channel, act_channel)
for player_id, player_chans in self.player_channels.items():
if player_chans.act_channel != 0:
await player_chans.act_channel.send("{} You are a {}.\n{}".format(message.guild.get_member(player_id).mention, self.game_comp[player_id].role_name, self.game_comp[player_id].whoami()))
