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 inserer_utilisateur(ligne):
utilisateur = modeles.Utilisateur(
prenom=ligne['prenom'].lower().capitalize(),
nom=ligne['nom'].lower().capitalize(),
email=ligne['email'],
telephone=str(ligne['telephone']),
confirmation=True,
notification_sms=True,
notification_email=True,
inscription=datetime.utcnow(),
adresse=ligne['adresse'],
mdp=ligne['mdp'])
db.session.add(utilisateur)
db.session.commit()
def index():
if current_user.is_authenticated == False:
form = rs.Demande_NonAuth()
else:
form = rs.Demande_Auth()
if form.validate_on_submit():
# Formattage de la date
date_course = str(form.date_debut.data) + " " + \
str(form.heures.data) + ":" + str(form.minutes.data) + ":00"
# On insère l'utilisateur s'il n'est pas dans la base
if current_user.is_authenticated == False:
utilisateur = modeles.Utilisateur(telephone=form.telephone.data,
prenom=form.prenom.data,
nom=form.nom.data,
email=form.mail.data,
categorie=form.categorie.data,
civilite=form.civilite.data)
db.session.add(utilisateur)
db.session.commit()
# On construit les adresses pour les géolocaliser
localisation_dep = ' '.join(
[form.numero_dep.data, form.adresse_dep.data, form.ville_dep.data])
localisation_arr = ' '.join(
[form.numero_arr.data, form.adresse_arr.data, form.ville_arr.data])
# Géocalisation des adressses de départ et d'arrivée
positions = {
'depart': geographie.geocoder(localisation_dep),
'arrivee': geographie.geocoder(localisation_arr)
}
# Adresse de départ
adresse_dep = modeles.Adresse(nom_rue=form.adresse_dep.data,
numero=form.numero_dep.data,
cp=form.cp_dep.data,
ville=form.ville_dep.data,
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(nom_rue=form.adresse_arr.data,
numero=form.numero_arr.data,
cp=form.cp_arr.data,
ville=form.ville_arr.data,
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=form.nb_passagers.data,
commentaire=form.commentaire.data,
debut=date_course,
trouvee=False,
finie=False)
if current_user.is_authenticated:
# Pas sur de ça
current_user.categorie = form.categorie.data
nouvelle_course.utilisateur = current_user.telephone
else:
nouvelle_course.utilisateur = form.telephone.data
db.session.add(nouvelle_course)
db.session.commit()
# Création d'une nouvelle facture
facture = modeles.Facture(course=nouvelle_course.numero,
paiement=form.paiement.data,
estimation=0,
montant=0,
rabais=0)
db.session.add(facture)
db.session.commit()
flash('La demande de réservation a été prise en compte.', 'positive')
donnees = form.data
return redirect(url_for('devis', form=donnees))
return render_template('index.html', form=form, titre='Réserver un taxi')
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'})