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'])