def oubli():
form = fu.Oubli()
if form.validate_on_submit():
utilisateur = modeles.Utilisateur.query.filter_by(
email=form.email.data).first()
# On vérifie que l'utilisateur existe
if utilisateur is not None:
# Sujet du mail de confirmation
sujet = 'Veuillez réinitialiser votre mot de passe.'
# Générer un token aléatoire
token = ts.dumps(utilisateur.email, salt='password-reset-key')
# Construire un lien de réinitialisation à partir du token
urlReinitialisation = url_for('utilisateurbp.reinitialisation',
token=token, _external=True)
# Le corps du mail est un template écrit en HTML
html = render_template('email/reinitialisation.html',
url_reinitialisation=urlReinitialisation)
# Envoyer le mail à l'utilisateur
email.envoyer(utilisateur.email, sujet, html)
# On renvoit à la page d'accueil
flash('Vérifiez vos mails pour réinitialiser votre mot de passe.',
'positive')
return redirect(url_for('index'))
else:
flash("Vous avez rentré une adresse email qui n'est pas associée " +
'à un compte.', 'negative')
return redirect(url_for('utilisateurbp.oubli'))
return render_template('utilisateur/oubli.html', form=form)
def rep_oui(numero, course):
''' Le conducteur répond 'OUI' à la proposition de la course détaillée. '''
try:
# Affectation du conducteur à cette course dans la table courses
db.session.execute("UPDATE courses SET conducteur = '{0}' WHERE numero = '{1}' ".format(numero, course))
# Statut = 'Occupé' dans la table conducteurs pour ce conducteur
db.session.execute("UPDATE conducteurs SET statut = 'Charge' WHERE telephone = '{}'".format(numero))
db.session.commit()
# Sujet de l'email
sujet = "Confirmation de la prise en charge de votre course"
# Corps de l'email
corps = render_template('email/corps_email.html')
# On récupère le numero de téléphone de l'utilisateur
requete = "SELECT u.telephone FROM utilisateurs u, courses c WHERE u.telephone = c.utilisateur AND c.numero = '{0}'".format(course)
telephone = db.session.execute(requete).first()
# On formate pour recuperer seulement le numero de telephone
telephone = str(telephone)[2:13]
# On récupere les informations de l'utilisateur avec en parametre le numero de telephone
utilisateur = modeles.Utilisateur.query.filter_by(
telephone=telephone).first()
# On envoye un email à l'utilisateur pour lui confirmer l'attribution de la course à un chauffeur
email.envoyer(utilisateur.email, sujet, corps)
return jsonify({'statut': 'succes'})
except:
return jsonify({'statut': 'echec'})
def oubli():
form = fu.Oubli()
if form.validate_on_submit():
utilisateur = modeles.Utilisateur.query.filter_by(
email=form.email.data).first()
# On vérifie que l'utilisateur existe
if utilisateur is not None:
# Sujet du mail de confirmation
sujet = 'Veuillez réinitialiser votre mot de passe.'
# Générer un token aléatoire
token = ts.dumps(utilisateur.email, salt='password-reset-key')
# Construire un lien de réinitialisation à partir du token
urlReinitialisation = url_for('utilisateurbp.reinitialisation',
token=token,
_external=True)
# Le corps du mail est un template écrit en HTML
html = render_template('email/reinitialisation.html',
url_reinitialisation=urlReinitialisation)
# Envoyer le mail à l'utilisateur
email.envoyer(utilisateur.email, sujet, html)
# On renvoit à la page d'accueil
flash('Vérifiez vos mails pour réinitialiser votre mot de passe.',
'positive')
return redirect(url_for('index'))
else:
flash(
"Vous avez rentré une adresse email qui n'est pas associée " +
'à un compte.', 'negative')
return redirect(url_for('utilisateurbp.oubli'))
return render_template('utilisateur/oubli.html', form=form)
def enregistrement():
form = fu.Enregistrement()
if form.validate_on_submit():
# Géolocaliser l'adresse
localisation = ' '.join([
form.numero.data,
form.adresse.data,
form.ville.data
])
position = geographie.geocoder(localisation)
# Créer une adresse
adresse = modeles.Adresse(
nom_rue=form.adresse.data,
numero=form.numero.data,
cp=form.cp.data,
ville=form.ville.data,
position='POINT({0} {1})'.format(position['lat'], position['lon'])
)
# Ajouter l'adresse à la BD
db.session.add(adresse)
db.session.commit()
# Créer un utilisateur qui n'a pas confirmé son mail
utilisateur = modeles.Utilisateur(
telephone=form.telephone.data,
email=form.email.data,
confirmation=False,
civilite=form.civilite.data,
categorie='Normal',
prenom=form.prenom.data,
nom=form.nom.data,
notification_email=True,
notification_sms=True,
adresse=adresse.identifiant,
mdp=form.mdp.data,
inscription=datetime.utcnow()
)
# Insérer un utilisateur dans la BD
db.session.add(utilisateur)
db.session.commit()
# Sujet du mail à envoyer
sujet = 'Veuillez confirmer votre adresse email.'
# Générer un token aléatoire
token = ts.dumps(utilisateur.email, salt='email-confirm-key')
# Construire un lien de confirmation à partir du token
urlConfirmation = url_for('utilisateurbp.confirmation',
token=token, _external=True)
# Le corps du mail est un template écrit en HTML
html = render_template('email/confirmation.html',
url_confirmation=urlConfirmation)
# Envoyer le mail à l'utilisateur
email.envoyer(utilisateur.email, sujet, html)
# On renvoit à la page d'accueil
signUpMsg = Markup(
"<i class='mail outline icon'></i>Vérifiez vos mails pour confirmer votre adresse email.")
flash(signUpMsg, 'positive')
return redirect(url_for('index'))
return render_template('utilisateur/enregistrement.html',
form=form, titre='Enregistrement')
def enregistrement():
form = fu.Enregistrement()
if form.validate_on_submit():
# Géolocaliser l'adresse
localisation = ' '.join([
form.numero.data,
form.adresse.data,
form.ville.data
])
position = geographie.geocoder(localisation)
# Créer une adresse
adresse = modeles.Adresse(
adresse=form.adresse.data,
numero=form.numero.data,
cp=form.cp.data,
ville=form.ville.data,
position='POINT({0} {1})'.format(position['lat'], position['lon'])
)
# Ajouter l'adresse à la BD
db.session.add(adresse)
db.session.commit()
# Créer un utilisateur qui n'a pas confirmé son mail
utilisateur = modeles.Utilisateur(
telephone=form.telephone.data,
email=form.email.data,
confirmation=False,
categorie='Normal',
prenom=form.prenom.data,
nom=form.nom.data,
notification_email=True,
notification_sms=True,
adresse=adresse.identifiant,
mdp=form.mdp.data,
inscription=datetime.utcnow()
)
# Insérer un utilisateur dans la BD
db.session.add(utilisateur)
db.session.commit()
# Sujet du mail à envoyer
sujet = 'Veuillez confirmer votre adresse email.'
# Générer un token aléatoire
token = ts.dumps(utilisateur.email, salt='email-confirm-key')
# Construire un lien de confirmation à partir du token
urlConfirmation = url_for('utilisateurbp.confirmation',
token=token, _external=True)
# Le corps du mail est un template écrit en HTML
html = render_template('email/confirmation.html',
url_confirmation=urlConfirmation)
# Envoyer le mail à l'utilisateur
email.envoyer(utilisateur.email, sujet, html)
# On renvoit à la page d'accueil
signUpMsg = Markup(
"<i class='mail outline icon'></i>Vérifiez vos mails pour confirmer votre adresse email.")
flash(signUpMsg, 'positive')
return redirect(url_for('index'))
return render_template('utilisateur/enregistrement.html',
form=form, titre='Enregistrement')
def contact():
form = fu.Contact()
if form.validate_on_submit():
msg = form.data
# Sujet du mail à envoyer
sujet = form.objet.data
# Le corps du mail est un template écrit en HTML
html = render_template('email/requete_utilisateur.html', msg=msg)
# Envoyer le mail à l'utilisateur
email.envoyer(app.config['ADMINS'][1], sujet, html)
flash('Votre email a été envoyé.', 'positive')
return redirect(url_for('index'))
return render_template('contact.html', titre='Contact', form=form)
def contact():
form = fu.Contact()
if form.validate_on_submit():
msg = form.data
# Sujet du mail à envoyer
sujet = form.objet.data
# Le corps du mail est un template écrit en HTML
html = render_template("email/requete_utilisateur.html", msg=msg)
# Envoyer le mail à l'utilisateur
email.envoyer(app.config["ADMINS"][1], sujet, html)
flash("Votre email a été envoyé.", "positive")
return redirect(url_for("index"))
return render_template("contact.html", titre="Contact", form=form)
def accepter():
# Récupération des données et formatage du JSON
data = request.get_json()
data = data.replace(''', '"')
data = eval(data)
demande = data['demande']
# On insère l'utilisateur s'il n'est pas dans la base
if current_user.is_authenticated == False:
utilisateur = modeles.Utilisateur(
telephone=demande['telephone'],
prenom=demande['prenom'],
nom=demande['nom'],
email=demande['mail'],
civilite=demande['civilite'],
)
db.session.add(utilisateur)
db.session.commit()
# Géocalisation des adressses de départ et d'arrivée
positions = {
'depart': geographie.geocoder(demande['adresse_dep']),
'arrivee': geographie.geocoder(demande['adresse_arr'])
}
# Adresse de départ
adresse_dep = modeles.Adresse(
position='POINT({0} {1})'.format(
positions['depart']['lat'],
positions['depart']['lon']
)
)
db.session.add(adresse_dep)
db.session.commit()
# Adresse d'arrivée
adresse_arr = modeles.Adresse(
position='POINT({0} {1})'.format(
positions['arrivee']['lat'],
positions['arrivee']['lon']
)
)
db.session.add(adresse_arr)
db.session.commit()
# Création de la course
nouvelle_course = modeles.Course(
depart = adresse_dep.identifiant,
arrivee = adresse_arr.identifiant,
places = demande['nb_passagers'],
commentaire = demande['commentaire'],
debut = demande['debut'],
trouvee = False,
finie = False,
animaux = demande['nb_animaux'],
bagages = demande['nb_bagages'],
animaux_grands = demande['animaux_grands']
)
if current_user.is_authenticated:
# Pas sur de ça
nouvelle_course.utilisateur = current_user.telephone
else:
nouvelle_course.utilisateur = demande['telephone']
db.session.add(nouvelle_course)
db.session.commit()
# Création d'une nouvelle facture
facture = modeles.Facture(
course=nouvelle_course.numero,
type_paiement=demande['paiement'],
estimation_1=0,
montant=0
)
db.session.add(facture)
db.session.commit()
# Envoi d'un email
if current_user.is_authenticated == False:
adresse_mail = demande['mail']
else:
adresse_mail = current_user.email
devis = data['devis']
# Sujet du mail à envoyer
sujet = 'Votre demande de réservation a été prise en compte.'
# Le corps du mail est un template écrit en HTML
html = render_template('email/facture.html', devis=devis)
# Envoyer le mail à l'utilisateur
email.envoyer(adresse_mail, sujet, html)
flash('La demande de réservation a été prise en compte.', 'positive')
return jsonify({'statut': 'succes'})
def accepter():
# Récupération des données et formatage du JSON
data = request.get_json()
data = data.replace(''', '"')
data = eval(data)
print(data)
demande = data['demande']
# On insère l'utilisateur s'il n'est pas dans la base
if current_user.is_authenticated == False:
utilisateur = modeles.Utilisateur(telephone=demande['telephone'],
prenom=demande['prenom'],
nom=demande['nom'],
email=demande['mail'],
civilite=demande['civilite'],
avoir_compte=False,
mdp=" ")
# L'utilisateur est-il déja dans la BD ?
check_Utilisateur = modeles.Utilisateur.query.filter_by(
telephone=demande['telephone']).first()
# Si l'utilisateur existe
if check_Utilisateur is not None:
# Alors on regarde s'il a un compte ou non
if check_Utilisateur.avoir_compte == False:
check_Utilisateur.nom = demande['nom']
check_Utilisateur.prenom = demande['prenom'],
check_Utilisateur.nom = demande['nom'],
check_Utilisateur.email = demande['mail'],
check_Utilisateur.avoir_compte = False,
# Sauvegarde des modifications
db.session.commit()
# S'il n'existe pas, on l'ajoute à la BD
else:
db.session.add(utilisateur)
db.session.commit()
# Géocalisation des adressses de départ et d'arrivée
positions = {
'depart': geographie.geocoder(demande['adresse_dep']),
'arrivee': geographie.geocoder(demande['adresse_arr'])
}
# Adresse de départ
adresse_dep = modeles.Adresse(position='POINT({0} {1})'.format(
positions['depart']['lat'], positions['depart']['lon']),
adr_complete=demande['adresse_dep'])
db.session.add(adresse_dep)
db.session.commit()
# Adresse d'arrivée
adresse_arr = modeles.Adresse(position='POINT({0} {1})'.format(
positions['arrivee']['lat'], positions['arrivee']['lon']),
adr_complete=demande['adresse_arr'])
db.session.add(adresse_arr)
db.session.commit()
# Création de la course
nouvelle_course = modeles.Course(depart=adresse_dep.identifiant,
arrivee=adresse_arr.identifiant,
places=demande['nb_passagers'],
commentaire=demande['commentaire'],
debut=demande['debut'],
trouvee=False,
finie=False,
animaux=demande['nb_animaux'],
bagages=demande['nb_bagages'],
animaux_grands=demande['animaux_grands'],
anglais=demande['langue'])
if current_user.is_authenticated:
# Pas sur de ça
nouvelle_course.utilisateur = current_user.telephone
else:
nouvelle_course.utilisateur = demande['telephone']
db.session.add(nouvelle_course)
db.session.commit()
devis = data['devis']
# Création d'une nouvelle facture
facture = modeles.Facture(course=nouvelle_course.numero,
type_paiement=demande['paiement'],
estimation_1=devis['prix']['total'],
montant=0)
db.session.add(facture)
db.session.commit()
# Envoi d'un email
if current_user.is_authenticated == False:
adresse_mail = demande['mail']
else:
adresse_mail = current_user.email
# Sujet du mail à envoyer
sujet = 'Votre demande de réservation a été prise en compte.'
# Le corps du mail est un template écrit en HTML
html = render_template('email/facture.html', devis=devis)
# Envoyer le mail à l'utilisateur
email.envoyer(adresse_mail, sujet, html)
# Appeler la fonction Scheduler
# planification.scheduler.add_job(attribution_course, demande['debut'], args=[str(nouvelle_course.numero)])
flash('La demande de réservation a été prise en compte.', 'positive')
return jsonify({'statut': 'succes'})