def index():
form = rs.Demande()
if form.validate_on_submit():
# Géolocaliser les adresses
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
])
depart = {'position': geographie.geocoder(localisation_dep)}
arrivee = {'position': geographie.geocoder(localisation_arr)}
adresse_dep = modeles.Adresse(
adresse=form.adresse_dep.data,
numero=form.numero_dep.data,
cp=form.cp_dep.data,
ville=form.ville_dep.data,
position='POINT({0} {1})'.format(
depart['position']['lat'], depart['position']['lon'])
)
adresse_arr = modeles.Adresse(
adresse=form.adresse_arr.data,
numero=form.numero_arr.data,
cp=form.cp_arr.data,
ville=form.ville_arr.data,
position='POINT({0} {1})'.format(
arrivee['position']['lat'], arrivee['position']['lon'])
)
# Ajouter l'adresse à la BD
db.session.add(adresse_dep)
db.session.add(adresse_arr)
db.session.commit()
flash('La demande de réservation a été prise en compte.', 'positive')
return redirect(url_for('index'))
return render_template('index.html', form=form, titre='Réserver un taxi')
def inserer_adresse(ligne):
adresse = modeles.Adresse(nom_rue=ligne['nom_rue'],
numero=ligne['numero'],
cp=ligne['cp'],
ville=ligne['ville'],
position='POINT({0} {1})'.format(
ligne['lat'], ligne['lon']))
db.session.add(adresse)
db.session.commit()
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 gps():
string = request.data.decode()
dt = json.loads(string)
# Fonction qui charge les données du trajet entre deux points (le départ est en lon,lat. L'arrivée en lon, lat ou textuelle)
lonposition = dt['lonposition']
latposition = dt['latposition']
#encoder l'adresse arriver
adresse = dt['adresse']
adresse = geocoder(adresse)
adresse_arr = modeles.Adresse(
position='POINT({0} {1})'.format(adresse['lat'], adresse['lon']))
latdestination = adresse['lat']
londestination = adresse['lon']
#URL format
mode = 'driving'
base = 'https://maps.googleapis.com/maps/api/directions/json?'
key = 'AIzaSyCBQSQ2Ze-8wEnZcT1V8__ug2WLdRmtdmA'
lang = 'fr'
a = '{lon},{lat}'.format(lat=latposition, lon=lonposition)
b = '{lat},{lon}'.format(lat=latdestination, lon=londestination)
url = '{0}origin={1}&destination={2}&language={3}&mode={4}&key={5}'.format(
base, a, b, lang, mode, key)
print(url)
#print(url)
data = urlopen(url).read().decode('utf-8')
jsonFile = load_json(data)
AdressDep = jsonFile['routes'][0]['legs'][0]['start_address']
AdressArr = jsonFile['routes'][0]['legs'][0]['end_address']
steps = jsonFile['routes'][0]['legs'][0]['steps']
distanceTot = jsonFile['routes'][0]['legs'][0]['distance']['text']
durationTot = jsonFile['routes'][0]['legs'][0]['duration']['text']
polyline = jsonFile['routes'][0]['overview_polyline']['points']
return jsonify({
'AdressDep': AdressDep,
'AdressArr': AdressArr,
'steps': steps,
'distanceTot': distanceTot,
'durationTot': durationTot,
'polyline': polyline
})
def inserer_adresse_station(ligne):
adresse = modeles.Adresse(position='POINT({0} {1})'.format(
ligne['lat'], ligne['lon']),
nom_rue=ligne['nom_rue'],
numero=ligne['numero'],
cp=ligne['cp'],
ville=ligne['ville'])
station = modeles.Station(nom=ligne['nom'],
distance_entree=ligne['entree'],
distance_sortie=ligne['sortie'])
db.session.add(station)
db.session.commit()
db.session.add(adresse)
db.session.commit()
adresse.station = station.nom
station.adresse = adresse.identifiant
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'})