def supprimer_sondage(key, nom_utilisateur):
## global selec_calendriers
## global sondag
db = get_db()
# On récupère les créneaux du sondage
eventdate = (db.execute(
'SELECT liste_options FROM sondage WHERE key = ?', (key,)
).fetchone())['liste_options']
# On récupère le(s) calendrier(s) complété(s)
calendriers = (db.execute(
'SELECT calendrier_nom FROM sondage_calendrier WHERE sondage_key = ? AND user_id = ?', (key,g.user['id'])
).fetchall())
numCal=0
# On efface les créneaux réservés par le sondage dans les calendriers et on supprime la participation dans le sondage Doodle
for i in range(len(calendriers)):
cal_nom = calendriers[i]['calendrier_nom']
calendrier = (db.execute(
'SELECT calendrier_fichier FROM calendrier WHERE calendrier_nom = ?', (cal_nom,)
).fetchone())['calendrier_fichier']
numCal=numCal+1
with_doodle.efface(eventdate, key, nom_utilisateur, calendrier, numCal)
#On supprime le sondage dans la base de données
db.execute('DELETE FROM creneau WHERE id IN (SELECT creneau_id FROM creneau_sondage WHERE sondage_key = ? AND user_id = ?)', (key,g.user['id']))
db.execute('DELETE FROM creneau_sondage WHERE sondage_key =? AND user_id = ?', (key,g.user['id']))
db.execute('DELETE FROM sondage_calendrier WHERE sondage_key =? AND user_id = ?', (key,g.user['id']))
db.execute('DELETE FROM sondage WHERE key IN (SELECT sondage_key FROM sondage_user WHERE sondage_key = ? AND user_id = ?)', (key,g.user['id']))
db.execute('DELETE FROM sondage_user WHERE sondage_key = ? AND user_id = ?', (key,g.user['id']))
db.commit()
return redirect(url_for('page_principale'))
def identifiants_oublies():
error = None
db = get_db()
if request.method == 'POST':
# On récupère la clé du sondage
mail = request.form['mail']
if not mail:
error = 'Veuillez entrer votre adresse mail.'
elif not envoi_mail.verif_mail(mail):
error = 'Veuillez entrer une adresse mail valide.'
# On vérifie que l'adresse mail est associée à un compte
elif db.execute('SELECT mail FROM user WHERE mail = ?',
(mail, )).fetchone() is None:
error = "Il n'y a pas de compte associé à l'adresse mail : {}.".format(
mail)
if error is not None:
flash(error)
else:
nom_utilisateur = (db.execute(
'SELECT username FROM user WHERE mail = ?',
(mail, )).fetchone())['username']
nouv_mdp = envoi_mail.mot_de_passe_oublie(mail, nom_utilisateur)
db.execute('UPDATE user SET password = ?'
' WHERE mail = ?',
(generate_password_hash(nouv_mdp), mail))
db.commit()
return redirect(url_for('auth.login'))
return render_template('mot_de_passe_oublie.html')
def modif_mot_de_passe(username, nom_doodle, mail):
## global selec_calendriers
## global sondag
error=None
db = get_db()
if request.method == 'POST':
ancien_mdp = request.form['mot_de_passe_0']
mdp = generate_password_hash(request.form['mot_de_passe_1'])
mdp_bis = request.form['mot_de_passe_2']
##print(check_password_hash(mdp, mdp_bis))
if not check_password_hash(g.user['password'], ancien_mdp):
error = 'Mot de passe incorrect.'
elif not mdp:
error = 'Veuillez entrer un mot de passe.'
elif not mdp_bis:
error = 'Veuillez entrer un mot de passe dans les deux champs.'
elif not check_password_hash(mdp, mdp_bis):
error = 'Veuillez entrer le même mot de passe dans les deux champs.'
if error is not None:
flash(error)
else:
db.execute(
'UPDATE user SET password = ?'
' WHERE id = ?',
(mdp, g.user['id'])
)
db.commit()
return render_template('parametres.html', username=username, nom_doodle=nom_doodle, mail=mail)
return render_template('modif_mot_de_passe.html')
def verification_code(username, nom_doodle, mail, code):
## global selec_calendriers
## global sondag
db = get_db()
error = None
# On récupère le code de vérification
if request.method == 'POST':
code_verif= request.form['code_verif']
if code_verif is None:
error = "Veuillez rentrer le code de vérification"
elif code != code_verif:
error = "Le code est erroné"
if error is not None:
flash(error)
else:
db.execute(
'UPDATE user SET mail = ?'
' WHERE id = ?',
(mail, g.user['id'])
)
db.commit()
return render_template('parametres.html', username=username, nom_doodle=nom_doodle, mail=mail)
return render_template('verification_code.html')
def inscription():
if request.method == 'POST':
username = request.form['username']
password = request.form['password']
nom_doodle = request.form['nom_doodle']
db = get_db()
error=None
if not username:
error = 'Veuillez entrer un nom d\'utilisateur.'
elif not password:
error = 'Veuillez entrer un mot de passe pour votre compte.'
elif not nom_doodle:
error = 'Veuillez entrer un nom pour le remplissage des Doodle.'
elif db.execute(
'SELECT id FROM user WHERE username = ?', (username,)
).fetchone() is not None:
error = 'L\'utilisateur {} existe déjà.'.format(username)
if error is None:
db.execute(
'INSERT INTO user (username, password, nom_doodle) VALUES (?, ?, ?)',
(username, generate_password_hash(password), nom_doodle)
)
db.commit()
return redirect(url_for('auth.login'))
flash(error)
return render_template('inscription.html')
def ajouter():
error = None
if request.method == 'POST':
key = request.form['key']
print(key)
if not key:
error = 'Veuillez entrer la clé du sondage.'
if error is not None:
flash(error)
else:
sond = with_doodle.recup_creneau(key)
titre = sond[3]
lieu = sond[4]
description = sond[5]
liste_options = sond[5]
date = datetime.now().date()
db = get_db()
db.execute(
'INSERT INTO sondage (key, titre, lieu, description,liste_options,date_maj)'
' VALUES (?, ?, ?, ?, ?)',
(key, titre, lieu, description, liste_options, date))
db.commit()
crenau_reserve = with_doodle.reserve_creneaux(sond[0], key)
#Ajouter les creneau reserve à la base de donnée!
return redirect(url_for('page_principale.liste_sondages'))
return render_template('ajouter.html')
def inscription_renvoi_code(username, password, nom_doodle):
# On récupère la nouvelle adresse mail
if request.method == 'POST':
mail = request.form['nouv_mail']
db = get_db()
error = None
if not mail:
error = 'Veuillez entrer une adresse mail.'
elif db.execute('SELECT mail FROM user WHERE mail = ?',
(mail, )).fetchone() is not None:
error = "Un compte est déjà associé à l'adresse mail : {}".format(
mail)
if error is not None:
flash(error)
else:
code = envoi_mail.code_verification(mail)
return render_template('verification_mail_inscription.html',
username=username,
password=password,
nom_doodle=nom_doodle,
mail=mail,
code=code)
return render_template('verification_mail_inscription.html',
username=username,
password=password,
nom_doodle=nom_doodle,
mail=mail,
code=code)
def ajouter_sondage_key():
error=None
existanceCalendrier = False
## global selec_calendriers
## global sondag
db = get_db()
if request.method == 'POST':
# On récupère la clé du sondage
key = request.form['key']
if not key:
error = 'Veuillez entrer la clé du sondage.'
# On vérifie que l'utilisateur n'a pas déjà ajouté ce sondage
elif db.execute(
'SELECT sondage_key FROM sondage_user WHERE sondage_key = ? AND user_id = ?', (key, g.user['id'])
).fetchone() is not None:
error = 'Vous avez déjà ajouté le sondage {}.'.format(key)
if error is not None:
flash(error)
else:
nom_utilisateur= (db.execute(
'SELECT nom_doodle FROM user WHERE id = ?', (g.user['id'],)
).fetchone())['nom_doodle']
# On récupère la liste des calendriers de l'utilisateur
liste_calendriers = db.execute(
'SELECT * FROM calendrier JOIN (SELECT calendrier_id FROM calendrier_user WHERE user_id = ?) cal ON calendrier.id=cal.calendrier_id',(g.user['id'],)
).fetchall()
return render_template('liste_calendriers.html', liste_calendriers=liste_calendriers,
key=key, nom_utilisateur=nom_utilisateur)
return render_template('ajouter_sondage.html')
def inscription_finalisation(username, password, nom_doodle, mail, code):
# On récupère le code de vérification
if request.method == 'POST':
code_verif = request.form['code_verif']
db = get_db()
error = None
if code_verif is None:
error = "Veuillez rentrer le code de vérification"
elif code != code_verif:
error = "Le code est erroné"
if error is not None:
flash(error)
else:
db.execute(
'INSERT INTO user (username, password, nom_doodle, mail) VALUES (?, ?, ?, ?)',
(username, generate_password_hash(password), nom_doodle, mail))
db.commit()
return redirect(url_for('page_principale'))
return render_template('verification_mail_inscription.html',
username=username,
password=password,
nom_doodle=nom_doodle,
mail=mail,
code=code)
def load_logged_in_user():
user_id = session.get('user_id')
if user_id is None:
g.user = None
else:
g.user = get_db().execute('SELECT * FROM user WHERE id = ?',
(user_id, )).fetchone()
def mise_a_jour_sondage(key,id,nom_utilisateur):
# On met la même clé (au hasard)
participant_key = "et5qinsv"
## global sondag
## global selec_calendriers
## sondag.clear()
db = get_db()
selec_calendriers = []
# On récupère les créneaux du sondage
eventdate = (db.execute(
'SELECT liste_options FROM sondage WHERE key = ?', (key,)
).fetchone())['liste_options']
# On récupère la liste des calendriers de l'utilisateur ainsi que le calendrier à compléter
liste_calendriers = (db.execute(
'SELECT * FROM calendrier JOIN (SELECT calendrier_id FROM calendrier_user WHERE user_id = ?) cal ON calendrier.id=cal.calendrier_id',(g.user['id'],)
).fetchall())
calendriers = (db.execute(
'SELECT calendrier_nom FROM sondage_calendrier WHERE sondage_key = ? AND user_id = ?', (key,g.user['id'])
).fetchall())
numCal=0
for i in range(len(calendriers)):
cal_nom = calendriers[i]['calendrier_nom']
selec_calendriers.append(cal_nom)
calendrier = (db.execute(
'SELECT calendrier_fichier FROM calendrier WHERE calendrier_nom = ?', (cal_nom,)
).fetchone())['calendrier_fichier']
# On supprime ensuite les événements correspondant dans le calendrier
numCal=numCal+1
with_doodle.efface(eventdate, key, nom_utilisateur, calendrier, numCal)
# On commence par supprimer des tables creneau et creneau_sondage les anciens créneaux préselectionnés
db.execute('DELETE FROM creneau WHERE id IN (SELECT creneau_id FROM creneau_sondage WHERE sondage_key = ? AND user_id = ?)', (key,g.user['id']))
db.execute('DELETE FROM creneau_sondage WHERE sondage_key =? AND user_id = ?', (key,g.user['id']))
db.commit()
# On récupère les créneaux où l'utilisateur est libre
sond=with_doodle.recup_creneau(key, nom_utilisateur, liste_calendriers)
eventdate = str(sond[0])
preferences = str(sond[1])
optionsHash = sond[2]
titre = sond[3]
lieu = sond[4]
description = sond[5]
jour_entier = str(sond[6])
final = str(sond[7])
limiteVotePers = str(sond[8])
siNecessaire = str(sond[9])
creneaux = db.execute(
'SELECT * FROM creneau JOIN creneau_sondage ON id=creneau_id WHERE sondage_key = ? AND user_id = ?', (key,g.user['id'])
).fetchall()
return render_template('liste_creneaux.html', creneaux=creneaux,key=key,id=g.user['id'],nom_utilisateur=nom_utilisateur,type="maj",eventdate=eventdate,
preferences=str(preferences),optionsHash=optionsHash,titre=titre,lieu=lieu,description=description,jour_entier=jour_entier,final=final,
limiteVotePers=limiteVotePers,siNecessaire=str(siNecessaire),cal=str(selec_calendriers))
def supprimer(key, nom_utilisateur):
db = get_db()
eventdate = eval(
(db.execute('SELECT liste_options FROM sondage WHERE key = ?',
(key, )).fetchone())['liste_options'])
with_doodle.efface(eventdate, key, nom_utilisateur)
db.execute('DELETE FROM sondage WHERE key = ?', (key, ))
db.execute('DELETE FROM sondage_user WHERE sondage_key = ?', (key, ))
db.commit()
return redirect(url_for('page_principale'))
def supprimer_calendrier(calendrier_id):
## global selec_calendriers
## global sondag
db = get_db()
db.execute(
'DELETE FROM calendrier WHERE id = ?',(calendrier_id,)
)
db.execute(
'DELETE FROM calendrier_user WHERE calendrier_id = ?', (calendrier_id,)
)
db.commit()
return redirect(url_for('page_principale'))
def ajouter_calendrier():
## global selec_calendriers
## global sondag
error=None
db = get_db()
if request.method == 'POST':
# On récupère l'adresse du fichier contenant le calendrier
fichier = request.files['calendrier_fichier']
# On vérifie que l'utilisateur a bien rentré l'adresse et qu'il n'a pas déjà ajouté ce calendrier
if not fichier:
error = 'Veuillez entrer le fichier.'
# On récupère le nom du calendrier
nom = request.form['calendrier_nom']
# On vérifie que l'utilisateur a bien rentré le nom et qu'il n'a pas déjà nommé un de ses calendriers de la même façon
if not nom:
error = 'Veuillez entrer un nom pour le calendrier.'
elif db.execute(
'SELECT calendrier_nom FROM calendrier JOIN (SELECT * FROM calendrier_user WHERE user_id = ?) cal ON calendrier.id=cal.calendrier_id WHERE calendrier_nom = ?',
(g.user['id'],nom,)).fetchone() is not None:
error = 'Ce nom de calendrier : "{}" existe déjà.'.format(nom)
if error is not None:
flash(error)
else:
# On récupère la possible description qu'il a donné à son calendrier
descr = request.form['description']
fichierTemp= str(g.user['id'])+'_'+nom+'.ics'
fichier.save(fichierTemp, 15000)
## f=open(fichierTemp,'r')
## fcal=Calendar.from_ical(f.read())
## print(len(fcal.subcomponents))
# On met à jour la base de données en complétant les tables calendrier et calendrier_user
db.execute(
'INSERT INTO calendrier (calendrier_nom,calendrier_fichier,description)'
' VALUES (?, ?,?)',
(nom,fichierTemp, descr)
)
id_calendrier= (db.execute(
'SELECT id FROM calendrier WHERE calendrier_fichier = ?',
(fichierTemp,)).fetchone()['id'])
db.execute(
'INSERT INTO calendrier_user (calendrier_id, user_id)'
' VALUES (?, ?)',
(id_calendrier,g.user['id'])
)
db.commit()
return redirect(url_for('page_principale'))
return render_template('ajouter_calendrier.html')
def mise_a_jour(key):
db = get_db()
#fonction de mise à jour du sondage
desc = 'Le sondage a été mis à jour'
date_maj = datetime.now().date()
db.execute(
'UPDATE sondage SET description = ?, date_maj = ?'
' WHERE key = ?', (desc, date_maj, key))
db.commit()
creneau_reserve = with_doodle.mise_a_jour(key, "bob")
#Remettre dans la base de donnée les nouveaux créneaux résérvésc
return redirect(url_for('page_principale'))
def liste_sondages_calendriers():
## global selec_calendriers
## global sondag
db = get_db()
#On récupère les sondages de l'utilisateur dans la base de données
sondages = db.execute(
'SELECT * FROM sondage JOIN (SELECT sondage_key FROM sondage_user WHERE user_id = ?) sond ON sondage.key=sond.sondage_key',(g.user['id'],)
).fetchall()
#On récupère les calendriers de l'utilisateur dans la base de données
calendriers = db.execute(
'SELECT * FROM calendrier JOIN (SELECT calendrier_id FROM calendrier_user WHERE user_id = ?) cal ON calendrier.id=cal.calendrier_id',(g.user['id'],)
).fetchall()
cal_selec = db.execute(
'SELECT * FROM sondage_calendrier WHERE user_id = ?',(g.user['id'],)
).fetchall()
return render_template('liste_sondages_calendriers.html', sondages=sondages, calendriers=calendriers, cal_selec=cal_selec)
def ajouter_sondage_selec_creneaux(key,nom_utilisateur):
## global selec_calendriers
## global sondag
error = None
db = get_db()
selec_calendriers = []
# On récupère la liste des calendriers de l'utilisateur
liste_calendriers = db.execute(
'SELECT * FROM calendrier JOIN (SELECT calendrier_id FROM calendrier_user WHERE user_id = ?) cal ON calendrier.id=cal.calendrier_id',(g.user['id'],)
).fetchall()
# On récupère l'adresse du fichier correspondant au calendrier demandé
if request.method == 'POST':
cal_ids= request.form
if len(cal_ids)==0:
error = 'Veuillez sélectionner un ou plusieurs calendriers.'
flash(error)
return render_template('liste_calendriers.html', liste_calendriers=liste_calendriers, key=key, nom_utilisateur=nom_utilisateur)
else:
# On récupère le nom des calendriers sélectionnés
for cal_id in cal_ids:
cal = db.execute(
'SELECT calendrier_nom FROM calendrier WHERE id = ?', (cal_id,)
).fetchone()['calendrier_nom']
selec_calendriers.append(cal)
# On récupère les créneaux du sondage où l'utilisateur est libre et on les ajoute à la base de données
sond = with_doodle.recup_creneau(key,nom_utilisateur,liste_calendriers)
eventdate = str(sond[0])
preferences = str(sond[1])
optionsHash = sond[2]
titre = sond[3]
lieu = sond[4]
description = sond[5]
jour_entier = str(sond[6])
final = str(sond[7])
limiteVotePers = str(sond[8])
siNecessaire = str(sond[9])
creneaux = db.execute(
'SELECT * FROM creneau JOIN creneau_sondage ON id=creneau_id WHERE sondage_key = ? AND user_id = ?',(key,g.user['id'])
).fetchall()
return render_template('liste_creneaux.html', creneaux=creneaux,key=key,id=g.user['id'],nom_utilisateur=nom_utilisateur,
type="ajout",eventdate=eventdate,preferences=preferences,optionsHash=optionsHash,titre=titre,
lieu=lieu,description=description,jour_entier=jour_entier,final=final,limiteVotePers=limiteVotePers,
siNecessaire=siNecessaire,cal=str(selec_calendriers))
return render_template('liste_calendriers.html', liste_calendriers=liste_calendriers, key=key, nom_utilisateur=nom_utilisateur)
def ajouter():
error = None
db = get_db()
if request.method == 'POST':
key = request.form['key']
if not key:
error = 'Veuillez entrer la clé du sondage.'
elif db.execute('SELECT key FROM sondage WHERE key = ?',
(key, )).fetchone() is not None:
error = 'Le sondage {} existe déjà.'.format(key)
if error is not None:
flash(error)
else:
try:
nom_utilisateur = (db.execute(
'SELECT nom_doodle FROM user WHERE id = ?',
(g.user['id'], )).fetchone())['nom_doodle']
#On met une clé au hasard
participant_key = "et5qinsv"
sond = with_doodle.recup_creneau(key, nom_utilisateur,
participant_key)
titre = sond[3]
lieu = sond[4]
description = sond[5]
final = sond[7]
date = datetime.now().date()
creneau_reserve = str(
with_doodle.reserve_creneaux(sond[0], sond[6], key))
db.execute(
'INSERT INTO sondage (key, titre, lieu, description,liste_options,date_maj,date_entree, est_final)'
' VALUES (?, ?, ?, ?, ?, ?, ?, ?)',
(key, titre, lieu, description, creneau_reserve, date,
date, final))
db.execute(
'INSERT INTO sondage_user (sondage_key, user_id)'
' VALUES (?, ?)', (key, g.user['id']))
db.commit()
return redirect(url_for('page_principale.liste_sondages'))
except:
flash('Clé de sondage invalide')
return render_template('ajouter.html')
def mise_a_jour(key, id, nom_utilisateur):
#on met la même clé (au hasard)
participant_key = "et5qinsv"
db = get_db()
eventdate = eval(
(db.execute('SELECT liste_options FROM sondage WHERE key = ?',
(key, )).fetchone())['liste_options'])
maj = with_doodle.mise_a_jour(key, nom_utilisateur, eventdate,
participant_key)
event_maj = str(maj[0])
date_maj = datetime.now().date()
db.execute(
'UPDATE sondage SET liste_options = ?, date_maj = ?, est_final = ?'
' WHERE key = ?', (event_maj, date_maj, maj[1], key))
db.commit()
return redirect(url_for('page_principale'))
def modif_calendrier(calendrier_fichier):
error=None
db = get_db()
try :
fichier = request.files['calendrier_fichier']
# On vérifie que l'utilisateur a bien rentré l'adresse et qu'il n'a pas déjà ajouté ce calendrier
if not fichier:
error = 'Veuillez entrer le fichier.'
if error is not None:
flash(error)
else:
# On récupère la possible description qu'il a donné à son calendrier
#descr = request.form['description']
fichierTemp= calendrier_fichier
fichier.save(fichierTemp, 15000)
return redirect(url_for('page_principale'))
except :
return render_template('modif_calendrier.html',calendrier_fichier=calendrier_fichier)
def inscription_envoi_code():
if request.method == 'POST':
username = request.form['username']
password = request.form['password']
nom_doodle = request.form['nom_doodle']
mail = request.form['mail']
db = get_db()
error = None
if not username:
error = 'Veuillez entrer un nom d\'utilisateur.'
elif not password:
error = 'Veuillez entrer un mot de passe pour votre compte.'
elif not nom_doodle:
error = 'Veuillez entrer un nom pour le remplissage des sondages Doodle.'
elif not mail:
error = 'Veuillez entrer une adresse mail.'
elif not envoi_mail.verif_mail(mail):
error = 'Veuillez entrer une adresse mail valide.'
elif db.execute('SELECT id FROM user WHERE username = ?',
(username, )).fetchone() is not None:
error = 'L\'utilisateur {} existe déjà.'.format(username)
elif db.execute('SELECT mail FROM user WHERE mail = ?',
(mail, )).fetchone() is not None:
error = "Un compte est déjà associé à l'adresse mail : {}".format(
mail)
if error is not None:
flash(error)
else:
code = envoi_mail.code_verification(mail)
return render_template('verification_mail_inscription.html',
username=username,
password=password,
nom_doodle=nom_doodle,
mail=mail,
code=code)
return render_template('inscription.html')
def login():
if request.method == 'POST':
username = request.form['username']
password = request.form['password']
db = get_db()
error = None
user = db.execute('SELECT * FROM user WHERE username = ?',
(username, )).fetchone()
if user is None:
error = 'Nom d\'utilisateur incorrect.'
elif not check_password_hash(user['password'], password):
error = 'Mot de passe incorrect.'
if error is None:
session.clear()
session['user_id'] = user['id']
return redirect(url_for('page_principale.liste_sondages'))
flash(error)
return render_template('login.html')
def modif_nom_doodle(username, nom_doodle, mail):
## global selec_calendriers
## global sondag
error=None
db = get_db()
if request.method == 'POST':
nom_doodle = request.form['nom_doodle']
if not nom_doodle:
error = 'Veuillez entrer un nom pour le remplissage des sondages Doodle.'
if error is not None:
flash(error)
else:
db.execute(
'UPDATE user SET nom_doodle = ?'
' WHERE id = ?',
(nom_doodle, g.user['id'])
)
db.commit()
return render_template('parametres.html', username=username, nom_doodle=nom_doodle, mail=mail)
return render_template('modif_nom_doodle.html')
def modif_mail(username, nom_doodle, mail):
## global selec_calendriers
## global sondag
error=None
db = get_db()
if request.method == 'POST':
mail = request.form['mail']
if not mail:
error = 'Veuillez entrer une adresse mail.'
elif not envoi_mail.verif_mail(mail):
error = 'Veuillez entrer une adresse mail valide.'
elif db.execute(
'SELECT mail FROM user WHERE mail = ?',
(mail,)).fetchone() is not None:
error = 'Cette adresse mail : "{}" est déjà associée à un autre compte.'.format(mail)
if error is not None:
flash(error)
else:
code = envoi_mail.code_verification(mail)
return render_template('verification_mail.html', username=username, nom_doodle=nom_doodle, mail=mail, code=code)
return render_template('modif_mail.html')
def login():
if request.method == 'POST':
username = request.form['username']
password = request.form['password']
db = get_db()
error = None
user = db.execute(
'SELECT * FROM user WHERE username = ?', (username,)
).fetchone()
if user is None:
error = 'Nom d\'utilisateur incorrect.'
elif not check_password_hash(user['password'], password):
error = 'Mot de passe incorrect.'
if error is None:
session.clear()
session['user_id'] = user['id']
if 'credentials' not in flask.session:
return flask.redirect(url_for('auth.authorize'))
# Charge les credentials de la session.
credentials = google.oauth2.credentials.Credentials(
**flask.session['credentials'])
service = googleapiclient.discovery.build(
API_SERVICE_NAME, API_VERSION, credentials=credentials)
flask.session['credentials'] = credentials_to_dict(credentials)
return redirect(url_for('page_principale.liste_sondages'))
flash(error)
return render_template('login.html')
def recup_creneau(key, nom_utilisateur, liste_calendriers):
db = get_db()
# 1er janvier 1970 en date python
a = datetime.datetime(1970, 1, 1)
# On stocke le json dans le dictionnaire l
r = rq.get(url + key)
l = json.loads(r.content)
optionsHash = l["optionsHash"]
# Le sondage peut être sur des créneaux horaires restreints ou sur des jours entiers.
# On initialise à False le booléen qui indique si le sondage est sur des jours entiers ou non.
jour_entier = False
# On considère que le sondage n'est pas final pour commencer
final = False
#On considère pour commencer que le sondage ne prends pas en compte l'option "si necessaire"
siNecessaire = False
if l['preferencesType'] == "YESNOIFNEEDBE":
siNecessaire = True
# La liste des options (créneaux) de notre Doodle (vide à l'initialisation)
liste_options = []
# La liste préférences est la liste de 0 et/ou 1 qu'il faut envoyer au Doodle pour le remplir
preferences = []
# Représente les places des créneaux finaux dans la liste des préférences
place = []
# Compteur représentant le nombre de créneaux
re = 0
# D'abord, on récupère la liste des dates des débuts et des fins (alternées 2 à 2) des événements du Doodle.
# Puis on distingue le cas où le Doodle est fermé ou non
try:
# On regarde si le sondage est fermé ou pas
t = l['closed']
final = True
# Si le sondage est fermé, on récupère tous les créneaux qui sont finaux
for temps in l["options"]:
jour_entier = jourEntier(temps)
try:
# On vérifie si l'événement est final
bool = temps['final']
# Date et heure de commencement de l'événement
secondesEnPlusDebut = int(
str(temps["start"])[0:len(str(temps["start"]))])
# On ajoute l'heure de début à la liste des options
# L'heure est ajoutée au format : datetime.datetime(yyyy, mm, dd, hh, mm, ss)
optionDebut = a + datetime.timedelta(
milliseconds=int(secondesEnPlusDebut) + 3600000)
#optionDebut = a + datetime.timedelta(milliseconds = int(secondesEnPlusDebut))
liste_options.append(optionDebut)
# Au début, on met par défaut que la personne est libre à tous les créneaux finaux
preferences.append(1)
# Vu qu'on récupère seulement les crénaux finaux, on conserve leur place dans la liste des préférences
place.append(re)
# Si le sondage n'est pas sur le jour entier, on récupère l'horaire de fin
if not jour_entier:
# Date et heure de fin de l'événement
secondesEnPlusFin = int(
str(temps["end"])[0:len(str(temps["end"]))])
# On l'ajoute à la liste des options
optionFin = a + datetime.timedelta(
milliseconds=int(secondesEnPlusFin) + 3600000)
#optionFin = a + datetime.timedelta(milliseconds = int(secondesEnPlusFin))
liste_options.append(optionFin)
except:
# Si la date n'est pas finale, on ajoute 0 aux préférences, et nous n'avons donc pas à nous soucier des dates non-finales
preferences.append(0)
re += 1
except:
# Si le sondage est toujours ouvert, on récupère tous les créneaux du Doodle
for temps in l["options"]:
jour_entier = jourEntier(temps)
# Date et heure de commencement de l'événement
secondesEnPlusDebut = int(
str(temps["start"])[0:len(str(temps["start"]))])
# Par défaut, on met dans la liste des préférences où on est libre à aucun créneau
preferences.append(0)
# On vérifie si le créneau est toujours disponible
if temps["available"]:
# On ajoute la place de chaque créneau dans la liste des préferences
place.append(re)
# On ajoute l'heure de début à la liste des options
optionDebut = a + datetime.timedelta(
milliseconds=int(secondesEnPlusDebut) + 3600000)
liste_options.append(optionDebut)
# Si le sondage n'est pas sur le jour entier, on récupère l'horaire de fin
if not jour_entier:
# Date et heure de fin de l'événement
secondesEnPlusFin = int(
str(temps["end"])[0:len(str(temps["end"]))])
# On ajoute les deux à la liste des options
optionFin = a + datetime.timedelta(
milliseconds=int(secondesEnPlusFin) + 3600000)
liste_options.append(optionFin)
re += 1
# On stocke les informations importantes du Doodle
titre = l["title"]
try:
lieu = l["location"]["name"]
except:
lieu = "Pas de lieu spécifié"
try:
description = l["description"]
except:
description = "Pas de description spécifiée"
try:
limiteVotePers = l['rowConstraint']
# S'il n'y a pas de limitation du nombre de votes par participant, on met le nombre de créneaux
except:
limiteVotePers = re
# Nous récupérons les événements du calendrier sur les créneaux récupérés dans listes_options
eventdate = []
test = []
# Pour chaque calendrier de l'utilisateur, on vérifie si les créneaux du sondage sont libres
for cal in liste_calendriers:
calendrier = cal['calendrier_fichier']
# Contient les créneaux du sondage libre dans le calendrier en cours
eventdateprov = []
# On récupère les dates de début et de fin des événements contenus dans le calendrier
events = with_ics.lectureCalendrier(calendrier)
n = len(liste_options)
# Un sondage ne peut être composé que de jours entiers ou de créneaux restreints, pas du mélange des 2
if jour_entier:
for i in range(n):
option = liste_options[i]
# Pour un sondage sur un jour entier, on a la liste des jours du sondage dans liste_options
jour = option.date()
journeeLibre = True
# On vérifie s'il y a déjà des événements dans le calendrier cette journée là
for (dateDeb, dateFin, Id) in events:
if dateDeb.date() == jour or dateFin.date() == jour:
journeeLibre = False
# S'il n'y a pas d'événement dans le calendrier cette journée là :
# On remplit le calendrier en réservant la journée et on modifie la liste preference en mettant 1 à la bonne place dans la liste
if journeeLibre:
eventdateprov.append(jour)
eventdateprov.append(i)
else:
for i in range(0, n, 2):
# Pour un sondage sur des créneaux restreints et non sur des jours entiers, on a successivement les horaires de début et de fin dans liste_options
# Si i est pair, c'est une date de début, sinon c'est une date de fin
debutCreneau = liste_options[i].replace(
tzinfo=timezone.utc).astimezone(tz=None)
finCreneau = liste_options[i + 1].replace(
tzinfo=timezone.utc).astimezone(tz=None)
creneauLibre = True
# On vérifie s'il y déjà des événements dans le calendrier sur le créneau
for (dD, dF, Id) in events:
# On remet les horaires sur le même fuseau horaire pour pouvoir les comparer
dateDebEvent = dD.replace(tzinfo=timezone.utc).astimezone(
tz=None)
dateFinEvent = dF.replace(tzinfo=timezone.utc).astimezone(
tz=None)
# Si un créneau débute ou se termine pendant un des événements du calendrier, cela signifie que l'utilisateur n'est pas libre
if dateDebEvent <= debutCreneau <= dateFinEvent or dateDebEvent <= finCreneau <= dateFinEvent or (
debutCreneau <= dateDebEvent <= finCreneau
and debutCreneau <= dateFinEvent <= finCreneau):
creneauLibre = False
# S'il n'y a pas d'évènement dans le calendrier à ce créneau, on ajoute la date de début et de fin du créneau à eventdateprov, ainsi que l'indice
# On remplit le calendrier en réservant le créneau et on modifie la liste preference en mettant 1 à la bonne place dans la liste
if creneauLibre:
eventdateprov.append(debutCreneau)
eventdateprov.append(finCreneau)
eventdateprov.append(i)
# On ajoute à la liste test la liste des créneaux retenus pour ce calendrier
test.append(eventdateprov)
# On ne remplit eventdate qu'avec les créneaux qui ont été retenus par tous les calendriers
# C'est-à-dire ceux contenus dans tous les eventdateprov correspondant à chaque calendrier
p = len(test)
# On va comparer les créneaux retenus par le 1er calendrier avec ceux retenus par les autres
q = len(test[0])
# On distingue toujours les sondages composés de journées entières et ceux composés de créneaux restreints
if jour_entier:
for i in range(0, q, 2):
bonCreneau = True
# On récupère un à un les créneaux retenus avec le 1er calendrier
creneau = test[0][i]
# Si pour un calendrier, le creneau n'apparait dans la liste des créneaux retenus, cela signifie que l'utilisateur n'est pas disponible pendant ce créneau
for j in range(1, p):
if creneau not in test[j]:
bonCreneau = False
# Si l'utilisateur est réellement disponible, on ajoute le creneau à eventdate et on remplit la liste des préférences à la place correspondant au créneau
if bonCreneau:
eventdate.append(creneau)
a = test[0][i + 1]
if siNecessaire:
preferences[place[a]] = 2
else:
preferences[place[a]] = 1
# Enfin, on complète les tables creneau et creneau_sondage de la base de données
db.execute(
'INSERT INTO creneau (cle,jourComplet)'
' VALUES (?, ?)', (
key + str(place[a]),
creneau,
))
id_creneau = (db.execute(
'SELECT MAX(id) FROM creneau WHERE cle = ?',
(key + str(place[a // 2]), )).fetchone()['id'])
db.execute(
'INSERT INTO creneau_sondage (creneau_id,sondage_key,user_id)'
' VALUES (?, ?)', (id_creneau, key, g.user['id']))
db.commit()
else:
for i in range(0, q, 3):
# On récupère les dates de début et de fin des créneaux retenus avec le 1er calendrier
debutCreneau = test[0][i]
finCreneau = test[0][i + 1]
# On crée une liste indiquant si le créneau a également été retenu par le j+1ème calendrier
contientCreneau = (p - 1) * [0]
# On compte le nombre de calendriers ayant retenus le calendrier
nbCal = 1
for j in range(1, p):
r = len(test[j])
for k in range(0, r, 3):
# Si le créneau a été retenu par le j+1ème calendrier, on passe la valeur de contientCreneau à 1
if test[j][k] == debutCreneau and test[j][k +
1] == finCreneau:
contientCreneau[j - 1] = 1
if contientCreneau[j - 1] != 0:
nbCal += 1
# Si le nombre de calendriers ayant retenu le créneau est égal au nombre total de calendriers, l'utilisateur est réellement disponilble
if nbCal == p:
# On ajoute le creneau à eventdate et on remplit la liste des préférences à la place correspondant au créneau
eventdate.append(debutCreneau)
eventdate.append(finCreneau)
a = test[0][i + 2]
if siNecessaire:
preferences[place[a // 2]] = 2
else:
preferences[place[a // 2]] = 1
# Enfin, on complète les tables creneau et creneau_sondage de la base de données
db.execute(
'INSERT INTO creneau (cle,debut,fin)'
' VALUES (?, ?,?)', (
key + str(place[a // 2]),
debutCreneau,
finCreneau,
))
id_creneau = (db.execute(
'SELECT MAX(id) FROM creneau WHERE cle = ?',
(key + str(place[a // 2]), )).fetchone()['MAX(id)'])
#print(id_creneau)
db.execute(
'INSERT INTO creneau_sondage (creneau_id,sondage_key,user_id)'
' VALUES (?, ?, ?)', (id_creneau, key, g.user['id']))
db.commit()
return eventdate, preferences, optionsHash, titre, lieu, description, jour_entier, final, limiteVotePers, siNecessaire
def supprimer(key):
db = get_db()
db.execute('DELETE FROM sondage WHERE key = ?', (key, ))
db.commit()
return redirect(url_for('page_principale'))
def ajouter_sondage_modif_creneaux(key,id,nom_utilisateur,type,eventdate,preferences,optionsHash,titre,lieu,description,jour_entier,final,limiteVotePers,siNecessaire,cal):
## global selec_calendriers
## global sondag
## print("Deuxième sondage")
## print(sondag)
selec_calendriers = eval(cal)
preferences = eval(preferences)
siNecessaire = eval(siNecessaire)
j=0
n=0
# On compte combien de créneaux ont été préselectionnés
for nombre in preferences:
if nombre!=0:
n=n+1
l=[0 for i in range (0,len(preferences))]
# On met la même clé (au hasard)
participant_key = "et5qinsv"
db = get_db()
creneaux = db.execute(
'SELECT * FROM creneau JOIN creneau_sondage ON id=creneau_id WHERE sondage_key = ? AND user_id = ?',(key,g.user['id'])
).fetchall()
if request.method == 'POST':
# On récupère les indices (dans la liste preferences) des créneaux que l'utilisateur a choisi
val1= request.form
print(len(val1))
if not siNecessaire and len(val1)>eval(limiteVotePers):
error = 'Vous avez voté pour trop de créneaux'
flash(error)
return render_template('liste_creneaux.html', creneaux=creneaux,key=key,id=g.user['id'],nom_utilisateur=nom_utilisateur,
type="ajout",eventdate=eventdate,preferences=str(preferences),optionsHash=optionsHash,titre=titre,
lieu=lieu,description=description,jour_entier=jour_entier,final=final,limiteVotePers=limiteVotePers,
siNecessaire=str(siNecessaire),cal=str(selec_calendriers))
# On parcourt la liste des indices
for k in val1:
if not siNecessaire:
l[int(k)]=1
# Si le sondage possède l'option 'si Necessaire' l'utilisateur a deux checkbox par créneau
else:
# 'O' correspond au cas où l'utilisateur indique qu'il sera présent sans condition
if k[0]=='O':
l[int(k[1])]=2
# 'S' correspond au cas où l'utilisateur indique qu'il sera présent si nécessaire
elif k[0]=='S':
if l[int(k[1])]==2:
error = 'Vous avez voté deux fois pour le même créneau'
flash(error)
return render_template('liste_creneaux.html', creneaux=creneaux,key=key,id=g.user['id'],nom_utilisateur=nom_utilisateur,
type="ajout",eventdate=eventdate,preferences=str(preferences),optionsHash=optionsHash,titre=titre,
lieu=lieu,description=description,jour_entier=jour_entier,final=final,limiteVotePers=limiteVotePers,
siNecessaire=str(siNecessaire),cal=str(selec_calendriers))
l[int(k[1])]=1
# On récupère la liste de créneaux préselectionnés
eventdate=eval(eventdate)
# Si le sondage n'est pas sur un jour entier
if not (eval(jour_entier)):
for i in range (len(l)-1,-1,-1):
if preferences[i]==1 or preferences[i]==2:
j=j+1
# On retire les créneaux que l'utilisateur n'a pas sélectionné
if (l[i]!=preferences[i] and not(siNecessaire and l[i]==1)):
eventdate.pop((n-j)*2+1) # Correspond à l'heure de fin
eventdate.pop((n-j)*2) # Correspond à l'heure de début
#Si le sondage est sur un jour entier
else:
for i in range (len(l)-1,-1,-1):
# On retire les créneaux que l'utilisateur n'a pas sélectionné
if preferences[i]==1 or preferences[i]==2:
j=j+1
if (l[i]!=preferences[i] and not(siNecessaire and l[i]==1)):
eventdate.pop((n-j))
# On convertit au bon format pour remplir le sondage Doodle puis on le remplit
eventdate2 = with_doodle.conversion(eventdate,titre,lieu,description,eval(jour_entier))
with_doodle.remplissage_doodle(l,optionsHash,key,nom_utilisateur,participant_key)
creneau_reserve=""
# On remplit le(s) calendrier(s) avec les créneaux:
for cal_nom in selec_calendriers:
calendrier = (db.execute(
'SELECT calendrier_fichier FROM calendrier WHERE calendrier_nom = ?', (cal_nom,)
).fetchone())['calendrier_fichier']
creneau_reserve=str(with_doodle.reserve_creneaux(eventdate2,eval(jour_entier),key,jour_entier,calendrier))
mail = (db.execute(
'SELECT mail FROM user WHERE id = ?', (g.user['id'],)
).fetchone())['mail']
envoi_mail.envoyer_calendrier(mail,calendrier)
date=datetime.datetime.now().date()
# S'il s'agit d'ajouter un sondage, on l'ajoute dans la base de données
if (type=="ajout"):
db.execute(
'INSERT INTO sondage (key, titre, lieu, description,liste_options,date_maj,date_entree,est_final)'
' VALUES (?, ?, ?, ?, ?, ?, ?, ?)',
(key, titre, lieu, description, creneau_reserve, date, date, final)
)
db.execute(
'INSERT INTO sondage_user (sondage_key, user_id)'
' VALUES (?, ?)',
(key, id)
)
for nom in selec_calendriers:
db.execute(
'INSERT INTO sondage_calendrier (sondage_key, calendrier_nom, user_id)'
' VALUES (?, ?, ?)',
(key, nom, id)
)
# S'il s'agit de mettre à jour un sondage, on fait juste une mise à jour de la base de données
elif (type=="maj"):
db.execute(
'UPDATE sondage SET liste_options = ?, date_maj = ?, est_final = ?'
' WHERE key = ?',
(creneau_reserve, date, final, key)
)
db.commit()
## sondag.clear()
## selec_calendriers.clear()
return redirect(url_for('page_principale'))
def liste_sondages():
db = get_db()
sondages = db.execute(
'SELECT * FROM sondage JOIN (SELECT sondage_key FROM sondage_user WHERE user_id = ?) sond ON sondage.key=sond.sondage_key',
(g.user['id'], )).fetchall()
return render_template('liste_sondages.html', sondages=sondages)
def parametres():
## global selec_calendriers
## global sondag
db = get_db()
return render_template('parametres.html', username=g.user['username'], nom_doodle=g.user['nom_doodle'], mail=g.user['mail'])
