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 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 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 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 gps(depart, arrivee):
arrivee = geocoder(arrivee)
base = 'https://maps.googleapis.com/maps/api/directions/json?'
key = 'AIzaSyCBQSQ2Ze-8wEnZcT1V8__ug2WLdRmtdmA'
url = '{0}'
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 type_tarif(demande):
#On récupère la date et l'heure de départ
date = demande['date_debut'].split('-')
annee_depart = int(date[0])
mois_depart = int(date[1])
jour_depart = int(date[2])
heure_depart = int(demande['heures'])
minutes_depart = int(demande['minutes'])
#Mise en forme de la date
date = datetime(annee_depart,mois_depart,jour_depart,heure_depart,minutes_depart)
#On concatenne les adresses de départ et d'arrivée
depart = demande['numero_dep'] + ' ' + demande['adresse_dep'] + ' ' + demande['cp_dep'] + ' ' + demande['ville_dep']
arrive = demande['numero_arr'] + ' ' + demande['adresse_arr'] + ' ' + demande['cp_arr'] + ' ' + demande['ville_arr']
#Recherche du tarif: Jour ou Nuit/JourFerie/Dimanche
#On calcule la date d'arrivée estimée du trajet
temps_trajet = timedelta(minutes=Par(geo.geocoder(depart),geo.geocoder(arrive),str(date)).temps)
date_arrive = date + temps_trajet
#On définit les limites de passages aux horaires jour et nuit
date_lim_jour = datetime.strptime(str(annee_depart) + '-' + str(mois_depart) + '-' + str(jour_depart) + ' 08:00:00', '%Y-%m-%d %H:%M:%S')
date_lim_soir = datetime.strptime(str(annee_depart) + '-' + str(mois_depart) + '-' + str(jour_depart) + ' 19:00:00', '%Y-%m-%d %H:%M:%S')
#On calcule le pourcentage de temps passé avec chaque tarif (nuit/jour) lorsqu'il y a un changement de tarif en cours de trajet
#Si le départ est avant 8h
if date < date_lim_jour:
#Si l'arrivée est entre 8h et 19h
if date_arrive >= date_lim_jour and date_arrive < date_lim_soir:
temps_nuit = (date_lim_jour - date)/temps_trajet
temps_jour = (date_arrive - date_lim_jour)/temps_trajet
intervalle = [round(temps_nuit,2), round(temps_jour,2)]
#Si l'arrivée est après 19h
elif date_arrive >= date_lim_soir:
temps_nuit = ((date_lim_jour - date) + (date_arrive - date_lim_soir))/temps_trajet
temps_jour = (date_lim_soir - date_lim_jour)/temps_trajet
intervalle = [round(temps_nuit,2), round(temps_jour,2)]
#Si le trajet est seulement de nuit
else:
intervalle = [1,0]
Type_tarif = 'TarifD'
#Si le départ est avant 19h
elif date < date_lim_soir:
#Si l'arrivée est après 19h et avant 8h le lendemain
if date_arrive >= date_lim_soir and date_arrive < date_lim_jour + timedelta(days=1):
temps_jour = (date_lim_soir - date)/temps_trajet
temps_nuit = (date_arrive - date_lim_soir)/temps_trajet
intervalle = [round(temps_nuit,2), round(temps_jour,2)]
#Si l'arrivée est après 8h le lendemain
elif date_arrive >= date_lim_jour + timedelta(days=1):
temps_nuit = ((date_lim_jour + timedelta(days=1)) - date_lim_soir)/temps_trajet
temps_jour = ((date_lim_soir - date) + (date_arrive - date_lim_jour + timedelta(days=1)))/temps_trajet
intervalle = [round(temps_nuit,2), round(temps_jour,2)]
#Si le trajet est seulement de jour
elif date_arrive < date_lim_soir:
intervalle = [0,1]
Type_tarif = 'TarifC'
#Si le départ est après 19h
elif date >= date_lim_soir:
#Si l'arrivée est entre 8h et 19h le lendemain
if date_arrive >= date_lim_jour + timedelta(days=1) and date_arrive < date_lim_soir + timedelta(days=1):
temps_nuit = ((date_lim_jour + timedelta(days=1)) - date) / temps_trajet
temps_jour = (date_arrive - date_lim_jour + timedelta(day=1))/temps_trajet
intervalle = [round(temps_nuit,2), round(temps_jour,2)]
#Si l'arrivée est après 19h le lendemain
elif date_arrive >= date_lim_soir + timedelta(days=1):
temps_nuit = (date + (date_lim_jour + timedelta(days=1)) + (date_arrive - (date_lim_soir + timedelta(days=1))))/temps_trajet
temps_jour = ((date_lim_soir + timedelta(days=1)) - (date_lim_jour + timedelta(days=1)))/temps_trajet
intervalle = [round(temps_nuit,2), round(temps_jour,2)]
#Si le trajet est seulement de nuit
else:
intervalle = [1,0]
Type_tarif = 'TarifD'
#On concaténe le mois et le jour de façon a avoir une chaine de la forme 'jour/mois'
dateC = str(date.day)+ '/' +str(date.month)
#On vérifie si la date en entrée est un jour ferie
ferie = dateC in [
'1/1',
'1/5',
'8/5',
'14/7',
'15/8',
'1/11',
'11/11',
'25/12'
]+feries(date.year)
#On vérifie si le jour est un dimanche
dimanche = date.weekday()
if ferie == True or dimanche == 6:
intervalle = [1,0]
Type_tarif = 'TarifD'
#Initialise les tarifs à utiliser en cas de changement de tarifs en cours de trajet
double_tarif = ['TarifD','TarifC']
return Type_tarif, intervalle, double_tarif,temps_trajet
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 estimation(demande):
''' Calculer le devis d'une demande. '''
# On récupère les tarifs applicables
tarifs = utile.lire_json('app/devis/data/tarifs.json')
supplements = utile.lire_json('app/devis/data/supplements.json')
# Extraction des information de départ
depart = geo.geocoder(demande['adresse_dep'])
arrivee = geo.geocoder(demande['adresse_arr'])
debut = demande['debut']
# Simulation de la course
simulation = calculer.simuler(depart, arrivee, debut)
duree = simulation['duree']
distance = simulation['distance']
jour = simulation['ratios']['jour']
nuit = simulation['ratios']['nuit']
# Savoir si c'est un jour ferié ou un dimanche
date = '{0}/{1}'.format(debut.day, debut.month)
jours_feries = calendrier.feries(debut.year)
ferie = date in jours_feries
dimanche = debut.weekday() == 6
# Décider du tarif à appliquer
if ferie or dimanche:
prix_par_km = tarifs['D']
else:
prix_par_km = jour * tarifs['C'] + nuit * tarifs['D']
# Calculer le prix de la course
montant = round(distance,1) * round(prix_par_km,2)
# Calculer le supplément
supplement = calculer_supplement(demande, supplements)
# Tarif supplémentaire appliqué à un trajet ralenti (si temps de trajet plus long de 5 minutes
# par rapport à temps de trajet de référence, on applique une nouvelle tarification par minute de trajet supplémentaire)
if round(simulation['ecart']/60) > 5:
diff_minutes = round(simulation['ecart']/60) - 5
else:
diff_minutes = 0
tarif_trajet_ralenti = diff_minutes * supplements['prix_trajet_ralenti']/60
# Calcul du total minimum estimé
total = montant + supplement + tarif_trajet_ralenti
# Prise en compte du tarif minimum
total = max(total, supplements['tarif_minimum'])
# On retourne l'estimation à travers un dictionnaire de données
estimation = {
'prix': {
'montant': round(montant, 2),
'supplement': round(supplement, 2),
'total': round(total,2)
},
'detail': {
'parcours': {
'duree': str(duree),
'distance': round(distance,2),
'prix_par_km': round(prix_par_km,2)
},
'bagages': {
'nb': demande['nb_bagages'],
'prix': supplements['bagage'],
'total': round(int(demande['nb_bagages']) * supplements['bagage'],2)
},
'animaux': {
'nb': demande['nb_animaux'],
'prix': supplements['animal'],
'total': round(int(demande['nb_animaux']) * supplements['animal'],2)
},
'personnes': {
'nb': demande['nb_passagers'],
'supplementaires': {
'nb': max(0, int(demande['nb_passagers']) - 4),
'prix': supplements['personne_sup'],
'total': round(max(0, int(demande['nb_passagers']) - 4) * supplements['personne_sup'],2)
}
},
'gare': {
'prise_en_charge': demande['gare'],
'prix': 0 if not demande['gare'] else supplements['gare']
},
'aeroport': {
'prise_en_charge': demande['aeroport'],
'prix': 0 if not demande['aeroport'] else supplements['aeroport']
},
'prise_en_charge': supplements['prise_en_charge'],
'tarif_trajet_ralenti' : round(tarif_trajet_ralenti,2),
'trajet_a_vide':supplements['trajet_a_vide']
}
}
return estimation
def __call__(self, form, field):
print(field.data)
position = geographie.geocoder(field.data)
if position['statut'] == 'echec':
raise ValidationError(self.message)
def __call__(self, form, field):
print(field.data)
position = geographie.geocoder(field.data)
if position['statut'] == 'echec':
raise ValidationError(self.message)
def tarifs(demande):
supp = pd.read_csv('app/devis/data/supplements.csv', encoding='utf8')
heures_tarif = pd.read_csv('app/devis/data/tarifs.csv', encoding='utf8')
#On initialise les prix de départ et les suppléments
prise_en_charge = supp[supp['Supplements'] == 'Prise_en_charge']
#On récupère la date et l'heure de départ
date = demande['date_debut'].split('-')
annee = int(date[0])
mois = int(date[1])
jour = int(date[2])
heure = int(demande['heures'])
minutes = int(demande['minutes'])
#Mise en forme de la date
date = datetime(annee, mois, jour, heure, minutes)
#On prend les lignes selon les types de tarifs et on en tire le prix associé
if tt.type_tarif(demande)[1] == [0, 1
] or tt.type_tarif(demande)[1] == [1, 0]:
#Tout le trajet en jour ou en nuit
ligne = heures_tarif[heures_tarif['Type_Tarif'] == tt.type_tarif(
demande)[0]]
prix = float(ligne['tarif_par_km'])
else:
#Trajet en partie en jour et en nuit
#Récupération du tarif de nuit
ligne = heures_tarif[heures_tarif['Type_Tarif'] == tt.type_tarif(
demande)[2][0]]
#Récupération du tarif de jour
ligne2 = heures_tarif[heures_tarif['Type_Tarif'] == tt.type_tarif(
demande)[2][1]]
#Calcul du prix/km par pourcentage du temps passé en tarif jour et nuit
prix = float(ligne['tarif_par_km']) * tt.type_tarif(
demande)[1][0] + float(ligne2['tarif_par_km']) * tt.type_tarif(
demande)[1][1] #avec pourcentage de jour et de nuit
#Calcul des suppléments
#On récupère les lignes selon les suppléments et leurs prix
an = supp[supp['Supplements'] == 'Animal']
bag = supp[supp['Supplements'] == 'Bagage']
PerS = supp[supp['Supplements'] == 'PersonneSup']
Gar = supp[supp['Supplements'] == 'Gare']
Aer = supp[supp['Supplements'] == 'Aeroport']
#Calcul du montant total des suppléments
#Suppléments pour bagages et/ou animaux
supplement = float(demande['bagage']) * float(bag['Prix']) + float(
demande['animaux']) * 1
#Suppléments pour un passager supplémentaire
if int(demande['nb_passagers']) > 4:
supplement += (float(demande['nb_passagers']) - 4) * float(
PerS['Prix'])
#Suppléments pour la prise en charge à la gare
if demande['gare'] == 'True':
supplement += float(Gar['Prix'])
#Suppléments pour la prise en charge à l'aéroport
if demande['aeroport'] == 'True':
supplement += float(Aer['Prix'])
#On concatenne les adresses de départ et d'arrivée
depart = demande['numero_dep'] + ' ' + demande[
'adresse_dep'] + ' ' + demande['cp_dep'] + ' ' + demande['ville_dep']
arrive = demande['numero_arr'] + ' ' + demande[
'adresse_arr'] + ' ' + demande['cp_arr'] + ' ' + demande['ville_arr']
#On calcule le prix total
# prix = coût de prise en charge + tarif par km * nombre de km + coût des suppléments
prixTotal = float(prise_en_charge['Prix']) + prix * round(
float(
Par(geo.geocoder(depart), geo.geocoder(arrive),
str(date)).distance), 2) + supplement
#On vérifie que le prix total soit supérieur au prix minimal
prixMinimal = float(supp[supp['Supplements'] == 'Tarif_minimum']['Prix'])
if prixTotal < prixMinimal:
prixTotal = prixMinimal
#On retourne le prix total via un dictionnaire de données
#Gestion des conditions
#Si le client est pris à l'aéroport
if demande['aeroport'] == 'True':
prixA = float(Aer['Prix'])
else:
prixA = 0
#Si le nombre de personne est supérieur à 4
if int(demande['nb_passagers']) > 4:
nbPersonnes = float(demande['nb_passagers']) - 4
else:
nbPersonnes = 0
#Si le client est pris à la gare
if demande['gare'] == 'True':
prixG = float(Gar['Prix'])
else:
prixG = 0
dico = {
'Prix_Total': str(round(prixTotal, 2)),
'Prise_en_charge': str(float(prise_en_charge['Prix'])),
'Prix_par_km': prix,
'Nombre_km': Par(geo.geocoder(depart), geo.geocoder(arrive),
str(date)).distance,
'Nombre_bagage': str(demande['bagage']),
'Prix_1_bagage': str(float(bag['Prix'])),
'prix_total_bagage':
str(float(demande['bagage']) * float(bag['Prix'])),
'animal': str(demande['animaux']),
'prix_animal': str(float(an['Prix'])),
'prix_total_animal':
str(float(demande['animaux']) * float(an['Prix'])),
'Gare': str(demande['gare']),
'Prix_Gare': str(prixG),
'Nombres_personnes_sup': nbPersonnes,
'Prix_par_personnes_sup': str(float(PerS['Prix'])),
'Prix_personnes_sup': str((nbPersonnes) * float(PerS['Prix'])),
'Aeroport': str(demande['aeroport']),
'Prix_Aeroport': str(prixA),
'Temps_course': str(tt.type_tarif(demande)[3])
}
#On retourne le prix total
return dico
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'})
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 gps(depart, arrivee):
arrivee = geocoder(arrivee)
base = 'https://maps.googleapis.com/maps/api/directions/json?'
key = 'AIzaSyCBQSQ2Ze-8wEnZcT1V8__ug2WLdRmtdmA'
url = '{0}'
def index():
form = rs.Demande()
# Formattage de la date
date_course = str(form.date_debut.data) + " " + \
str(form.heures.data) + ":" + str(form.minutes.data) + ":00"
if form.validate_on_submit():
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
)
# Ajout de l'utilisateur à la BD
db.session.add(utilisateur)
db.session.commit()
# 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
])
# Géocalisation des adressses de départ et d'arrivée
depart = {'position': geographie.geocoder(localisation_dep)}
arrivee = {'position': geographie.geocoder(localisation_arr)}
# Adresse de départ
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 d'arrivée
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)
# Modification de la tarification appliquée à l'utilisateur si il est
# connecté
if current_user.is_authenticated:
current_user.categorie = form.categorie.data
# Création d'une nouvelle course pour un utilisateur connecté
nouvelle_course = modeles.Course(
utilisateur=current_user.telephone,
depart=adresse_dep.identifiant,
arrivee=adresse_arr.identifiant,
places=form.nb_passagers.data,
commentaire=form.commentaire.data,
debut=date_course,
trouvee=False,
finie=False)
else:
# Création d'une nouvelle course pour un utilisateur non-connecté
nouvelle_course = modeles.Course(
utilisateur=form.telephone.data,
depart=adresse_dep.identifiant,
arrivee=adresse_arr.identifiant,
places=form.nb_passagers.data,
commentaire=form.commentaire.data,
debut=date_course,
trouvee=False,
finie=False)
# Ajout de la course à la BD
db.session.add(nouvelle_course)
db.session.commit()
# Création d'une nouvelle facture
nouvelle_facture = modeles.Facture(
course=nouvelle_course.numero,
paiement=form.paiement.data,
estimation=0,
montant=0,
rabais=0
)
# Ajout de la facture à la BD
db.session.add(nouvelle_facture)
# Sauvegarde des transations
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 tarifs(demande):
supp = pd.read_csv('app/devis/data/supplements.csv', encoding='utf8')
heures_tarif = pd.read_csv('app/devis/data/tarifs.csv', encoding='utf8')
#On initialise les prix de départ et les suppléments
prise_en_charge = supp[supp['Supplements'] == 'Prise_en_charge']
#On récupère la date et l'heure de départ
date = demande['date_debut'].split('-')
annee = int(date[0])
mois = int(date[1])
jour = int(date[2])
heure = int(demande['heures'])
minutes = int(demande['minutes'])
#Mise en forme de la date
date = datetime(
annee,
mois,
jour,
heure,
minutes
)
#On prend les lignes selon les types de tarifs et on en tire le prix associé
if tt.type_tarif(demande)[1] == [0,1] or tt.type_tarif(demande)[1] == [1,0]:
#Tout le trajet en jour ou en nuit
ligne = heures_tarif[heures_tarif['Type_Tarif'] == tt.type_tarif(demande)[0]]
prix = float(ligne['tarif_par_km'])
else:
#Trajet en partie en jour et en nuit
#Récupération du tarif de nuit
ligne = heures_tarif[heures_tarif['Type_Tarif'] == tt.type_tarif(demande)[2][0]]
#Récupération du tarif de jour
ligne2 = heures_tarif[heures_tarif['Type_Tarif'] == tt.type_tarif(demande)[2][1]]
#Calcul du prix/km par pourcentage du temps passé en tarif jour et nuit
prix = float(ligne['tarif_par_km']) * tt.type_tarif(demande)[1][0] + float(ligne2['tarif_par_km']) * tt.type_tarif(demande)[1][1] #avec pourcentage de jour et de nuit
#Calcul des suppléments
#On récupère les lignes selon les suppléments et leurs prix
an= supp[supp['Supplements'] == 'Animal']
bag = supp[supp['Supplements'] == 'Bagage']
PerS = supp[supp['Supplements'] == 'PersonneSup']
Gar = supp[supp['Supplements'] == 'Gare']
Aer = supp[supp['Supplements'] == 'Aeroport']
#Calcul du montant total des suppléments
#Suppléments pour bagages et/ou animaux
supplement = float(demande['bagage']) * float(bag['Prix']) + float(demande['animaux']) * 1
#Suppléments pour un passager supplémentaire
if int(demande['nb_passagers']) > 4:
supplement += (float(demande['nb_passagers'])-4) * float(PerS['Prix'])
#Suppléments pour la prise en charge à la gare
if demande['gare'] == 'True':
supplement += float(Gar['Prix'])
#Suppléments pour la prise en charge à l'aéroport
if demande['aeroport'] == 'True':
supplement += float(Aer['Prix'])
#On concatenne les adresses de départ et d'arrivée
depart = demande['numero_dep'] + ' ' + demande['adresse_dep'] + ' ' + demande['cp_dep'] + ' ' + demande['ville_dep']
arrive = demande['numero_arr'] + ' ' + demande['adresse_arr'] + ' ' + demande['cp_arr'] + ' ' + demande['ville_arr']
#On calcule le prix total
# prix = coût de prise en charge + tarif par km * nombre de km + coût des suppléments
prixTotal = float(prise_en_charge['Prix']) + prix * round(float(Par(geo.geocoder(depart),geo.geocoder(arrive),str(date)).distance),2) + supplement
#On vérifie que le prix total soit supérieur au prix minimal
prixMinimal = float(supp[supp['Supplements'] == 'Tarif_minimum']['Prix'])
if prixTotal < prixMinimal:
prixTotal = prixMinimal
#On retourne le prix total via un dictionnaire de données
#Gestion des conditions
#Si le client est pris à l'aéroport
if demande['aeroport'] == 'True':
prixA = float(Aer['Prix'])
else:
prixA = 0
#Si le nombre de personne est supérieur à 4
if int(demande['nb_passagers']) > 4:
nbPersonnes = float(demande['nb_passagers']) - 4
else:
nbPersonnes = 0
#Si le client est pris à la gare
if demande['gare'] == 'True':
prixG = float(Gar['Prix'])
else:
prixG = 0
dico = {
'Prix_Total' : str(round(prixTotal,2)),
'Prise_en_charge' : str(float(prise_en_charge['Prix'])),
'Prix_par_km' : prix,
'Nombre_km' : Par(geo.geocoder(depart),geo.geocoder(arrive),str(date)).distance,
'Nombre_bagage' : str(demande['bagage']),
'Prix_1_bagage' : str(float(bag['Prix'])),
'prix_total_bagage' : str(float(demande['bagage']) * float(bag['Prix'])),
'animal' : str(demande['animaux']),
'prix_animal' : str(float(an['Prix'])),
'prix_total_animal' : str(float(demande['animaux']) * float(an['Prix'])),
'Gare' : str(demande['gare']),
'Prix_Gare' : str(prixG),
'Nombres_personnes_sup' : nbPersonnes,
'Prix_par_personnes_sup' : str(float(PerS['Prix'])),
'Prix_personnes_sup' : str((nbPersonnes) * float(PerS['Prix'])),
'Aeroport' : str(demande['aeroport']),
'Prix_Aeroport':str(prixA)
}
#On retourne le prix total
return dico
def estimation(demande):
''' Calculer le devis d'une demande. '''
# On récupère les tarifs applicables
tarifs = utile.lire_json('app/devis/data/tarifs.json')
supplements = utile.lire_json('app/devis/data/supplements.json')
# Prise en charge de départ
prise_en_charge = supplements['prise_en_charge']
# Extraction des information de départ
depart = geo.geocoder(demande['adresse_dep'])
arrivee = geo.geocoder(demande['adresse_arr'])
debut = demande['debut']
# Simulation de la course
simulation = calculer.simuler(depart, arrivee, debut)
duree = simulation['duree']
distance = simulation['distance']
jour = simulation['ratios']['jour']
nuit = simulation['ratios']['nuit']
# Savoir si c'est un jour ferié ou un dimanche
date = '{0}/{1}'.format(debut.day, debut.month)
jours_feries = calendrier.feries(debut.year)
ferie = date in jours_feries
dimanche = debut.weekday() == 6
# Décider du tarif à appliquer
if ferie or dimanche:
prix_par_km = tarifs['D']
else:
prix_par_km = jour * tarifs['C'] + nuit * tarifs['D']
# Calculer le prix de la course
montant = distance * prix_par_km
# Prix du trajet à vide
tav = supplements['trajet_a_vide']
# Calculer le supplément
supplement = calculer_supplement(demande, supplements)
# Tarif supplémentaire appliqué à un trajet ralenti (si temps de trajet plus long de 5 minutes
# par rapport à temps de trajet de référence, on applique une nouvelle tarification par minute de trajet supplémentaire)
if round(simulation['ecart']/60) > 5:
diff_minutes = round(simulation['ecart']/60) - 5
else:
diff_minutes = 0
estimation = diff_minutes * supplements['prix_trajet_ralenti']/60
# Calcul du total minimum estimé
total = montant + supplement + tav + estimation
# Prise en compte du tarif minimum
total = max(total, supplements['tarif_minimum'])
# On retourne l'estimation à travers un dictionnaire de données
estimation = {
'prix': {
'montant': round(montant, 2),
'supplement': round(supplement, 2),
'trajet_a_vide' : tav,
'total': round(total,2)
},
'detail': {
'parcours': {
'duree': str(duree),
'distance': round(distance,1),
'prix_par_km': prix_par_km
},
'bagages': {
'nb': demande['nb_bagages'],
'prix': supplements['bagage'],
'total': int(demande['nb_bagages']) * supplements['bagage']
},
'animaux': {
'nb': demande['nb_animaux'],
'prix': supplements['animal'],
'total': int(demande['nb_animaux']) * supplements['animal']
},
'personnes': {
'nb': demande['nb_passagers'],
'supplementaires': {
'nb': max(0, int(demande['nb_passagers']) - 4),
'prix': supplements['personne_sup'],
'total': max(0, int(demande['nb_passagers']) - 4) * supplements['personne_sup']
}
},
'gare': {
'prise_en_charge': demande['gare'],
'prix': 0 if not demande['gare'] else supplements['gare']
},
'aeroport': {
'prise_en_charge': demande['aeroport'],
'prix': 0 if not demande['aeroport'] else supplements['aeroport']
},
'prise_en_charge': supplements['prise_en_charge']
}
}
return estimation