def FUN_login():
id_submitted = request.form.get("id").upper()
if (id_submitted in list_users()) and verify(id_submitted,
request.form.get("pw")):
session['current_user'] = id_submitted
return (redirect(url_for("FUN_root")))
def verifydatabase(name, token):
if apptoken.verify(token):
if db.verify(name):
return Response("Database already exist", status=302)
else:
return Response("Database doesn't exist")
else:
return Response("Invalid authorization", status=401)
def login():
if "user" in session:
return redirect(url_for("index"))
elif request.method == "POST":
username = request.form["username"]
password = request.form["password"]
if database.verify(username, password):
session["user"] = username
return redirect(url_for("index"))
return render_template("login.html")
def login():
if "user" in session:
return redirect(url_for("index"))
elif request.method == "POST":
username = request.form["username"]
password = request.form["password"]
if database.verify(username, password):
session["user"] = username
return redirect(url_for("index"))
return render_template("login.html")
def FUN_login():
id_submitted = request.form.get("id").upper()
if (id_submitted in list_users()) and verify(id_submitted,
request.form.get("pw")):
session['current_user'] = id_submitted
return (redirect(url_for("welcome")))
else:
#return(redirect(url_for("FUN_root")))
return render_template("index.html", wrong_id_pass=True)
async def authenticate(client, dbFileName, message):
entities = message["entities"]
success = database.verify(dbFileName, entities)
#activeSession = connections.activeSession(entities)
anyActive = connections.anyActive(entities)
# more flexibility possible, but good enough for now
if success == False or anyActive == True:
await messages.respond(client, message, {'status': 'failed'})
else:
connections.remember(client, entities)
await messages.respond(client, message, {'status': 'success'})
async def authenticate(client, dbFileName, message):
accounts = utilities.unpackAccounts(message["accounts"])
successful, failed = database.verify(dbFileName, accounts)
# activeSession = connections.activeSession(entities)
# anyActive = connections.anyActive(entities)
# more flexibility possible, but good enough for now
connections.remember(client, [account["id"] for account in successful])
await messages.respond(client, message, {
"successful": utilities.packAccounts(successful),
"failed": utilities.packAccounts(failed)
});
def search(self):
valide = verify([self.nom, self.contact])
if not valide:
self.error.config(text="Touts les champs sont obligatoires")
self.info["text"] = ""
else:
self.error.config(text="")
result = self.mydb.recuva(self.nom.get().strip().upper(),
self.contact.get().strip())
if not result:
self.info.config(fg="red", text="Aucune correspondance !")
else:
self.info.config(fg="green", text=result)
def saveService(self):
all_is_valide = verify(self.champs_list)
if not self.description.get("1.0", "end").strip():
self.description.config(bg="red")
self.master.bell()
all_is_valide = False
else:
self.description.config(bg="#fff")
if all_is_valide:
values = (self.nom.get().strip().upper(),
self.description.get("1.0", "end").capitalize(),
self.batiment.get().strip().title())
self.mydb.setService(values)
[e.delete(0, "end") for e in self.champs_list]
self.description.delete("1.0", "end")
async def sendMessage(client, dbFileName, message):
if (connections.verify(client, message["from"])
and database.verify(client, {
"id": message["from"],
"password": message["password"]
})):
receiverClient = connections.getClient(message["to"])
if receiverClient is not None:
await messages.send(
receiverClient, 'new message', {
'from': message["from"],
'to': message["to"],
'message': message["message"]
}, True)
def insert_db():
cham = [e1, e2, e4, e5]
validate = verify(cham)
if not validate: return
specialite = e3.get()
liste = [item for item in services if specialite in item][0]
service_id = liste[0]
values = tuple([
e1.get().strip().upper(),
e2.get().strip().title(), service_id,
e4.get().strip(),
e5.get().strip()
])
mydb.setMedecin(values)
[e.delete(0, "end") for e in cham]
def enregistrer(self):
id = self.medecins[self.medLst.index(self.var_medecin.get())][0]
is_valide = verify([self.adresse, self.contact])
if is_valide:
self.mydb.updateMedecin(
self.adresse.get().strip().replace('"', ''),
self.contact.get().strip().replace('"', ''), id)
self.info.config(bg="#0f5",
fg="#fff",
text="Modification effectue")
self.medecins = self.mydb.getAll("medecin")
self.medLst = [
"Docteur: {0} {1}".format(medecin[1], medecin[2])
for medecin in self.medecins
]
else:
self.info.config(bg="red",
fg="#fff",
text="Veuillez remplire touts les champs")
def insert_db(self):
date = time.strftime("%d/%m/%Y %H:%M:%S")
self.liste_entr = [
self.entry_nom, self.entry_prenom, self.entry_age,
self.entry_contact, self.entry_address, self.entry_reference
]
validate = verify(self.liste_entr)
if not self.entry_age.get().strip().isdigit():
validate = False
self.entry_age["bg"] = "red"
self.root.after(2000,
lambda col="#fff": self.entry_age.config(bg=col))
if validate:
idt = "med@{0}{1}{2}{3}".format(time.strftime("%H%M%Y%S"),
self.entry_nom.get().strip()[0],
time.strftime("%d%m"),
self.entry_prenom.get()[0])
values = [
idt,
self.entry_nom.get().strip().upper(),
self.entry_prenom.get().strip().title(),
self.entry_age.get().strip(),
self.entry_contact.get().strip(),
self.entry_address.get().strip(),
self.entry_reference.get().strip(), date
]
self.mydb.setPatient(tuple(values))
for i in self.liste_entr:
i.delete("0", "end")
values = (idt, date, 1)
self.mydb.setCompte(values)
self.info.config(fg="green", text="Enregistrement effectue !")
self.info.after(3000, lambda: self.info.config(text=""))
self.services_desc(idt)
else:
self.info.config(fg="red", text="L'enregistrement a echoue !")
self.info.after(3000, lambda: self.info.config(text=""))
def continuer(self):
all_is_valide = verify(self.champs_list)
if all_is_valide:
if float(self.var_taille.get()) < 0.1 or float(
self.var_taille.get()) > 2.55:
self.champ_taille["bg"] = "red"
self.bell()
return
else:
self.champ_taille["bg"] = "#fff"
date_time = tm.strftime("%d/%m/%Y %H:%M:%S")
values = tuple([self.id_patient, self.id_medecin, date_time] +
[value.get().strip()
for value in self.champs_list] +
[self.champ_diagn.get(index1="1.0", index2="end")])
self.mydb.setConsultation(values)
info = self.mydb.getOne("consultation", "date", date_time)
Examen(consultation=info[0], date=date_time, destroyThis=self)
