303 lines
12 KiB
Python
303 lines
12 KiB
Python
from datetime import datetime
|
|
|
|
import requests, json
|
|
from django.contrib import messages
|
|
from django.db import connection
|
|
from django.http import HttpResponseRedirect, HttpResponse, Http404
|
|
from django.shortcuts import render
|
|
from django.utils import timezone
|
|
from rest_framework.generics import get_object_or_404
|
|
|
|
import stripe
|
|
|
|
# Create your views here.
|
|
from django.views import View
|
|
from rest_framework import status
|
|
|
|
from BaseBillet.models import Configuration, Article, TarifsAdhesion, LigneArticle
|
|
from PaiementStripe.models import Paiement_stripe
|
|
from PaiementStripe.views import creation_checkout_stripe
|
|
from QrcodeCashless.models import CarteCashless
|
|
import logging
|
|
logger = logging.getLogger(__name__)
|
|
|
|
|
|
def get_domain(request):
|
|
absolute_uri = request.build_absolute_uri()
|
|
for domain in request.tenant.domains.all():
|
|
if domain.domain in absolute_uri:
|
|
return domain.domain
|
|
|
|
raise Http404
|
|
|
|
def check_carte_local(uuid):
|
|
carte = get_object_or_404(CarteCashless, uuid=uuid)
|
|
return carte
|
|
|
|
class gen_one_bisik(View):
|
|
def get(self, request, numero_carte):
|
|
print(numero_carte)
|
|
carte = get_object_or_404(CarteCashless, number=numero_carte)
|
|
address = request.build_absolute_uri()
|
|
return HttpResponseRedirect(
|
|
address.replace("://m.", "://bisik.").replace(f"{carte.number}", f"qr/{carte.uuid}"))
|
|
|
|
|
|
class index_scan(View):
|
|
template_name = "html5up-dimension/index.html"
|
|
|
|
def __init__(self, *args, **kwargs):
|
|
super().__init__(*args, **kwargs)
|
|
self.carte = None
|
|
self.adhesion = None
|
|
|
|
def check_carte_serveur_cashless(self, uuid):
|
|
configuration = Configuration.get_solo()
|
|
# on questionne le serveur cashless pour voir si la carte existe :
|
|
|
|
sess = requests.Session()
|
|
try:
|
|
reponse = sess.post(
|
|
f'{configuration.server_cashless}/api/billetterie_endpoint',
|
|
headers={
|
|
'Authorization': f'Api-Key {configuration.key_cashless}'
|
|
},
|
|
data={
|
|
'uuid': f'{uuid}',
|
|
})
|
|
except requests.exceptions.ConnectionError:
|
|
reponse = HttpResponse("Serveur non disponible. Merci de revenir ultérieurement.",
|
|
status=status.HTTP_503_SERVICE_UNAVAILABLE)
|
|
|
|
sess.close()
|
|
return reponse
|
|
|
|
def get(self, request, uuid):
|
|
carte = check_carte_local(uuid)
|
|
if carte.detail.origine != connection.tenant:
|
|
raise Http404
|
|
|
|
# dette technique ...
|
|
# pour rediriger les premières générations de qrcode
|
|
# m.tibillet.re et raffinerie
|
|
address = request.build_absolute_uri()
|
|
host = address.partition('://')[2]
|
|
sub_addr = host.partition('.')[0]
|
|
if sub_addr == "m":
|
|
return HttpResponseRedirect(address.replace("://m.", "://raffinerie."))
|
|
|
|
configuration = Configuration.get_solo()
|
|
if not configuration.server_cashless:
|
|
return HttpResponse(
|
|
"L'adresse du serveur cashless n'est pas renseignée dans la configuration de la billetterie.")
|
|
if not configuration.stripe_api_key or not configuration.stripe_test_api_key:
|
|
return HttpResponse(
|
|
"Pas d'information de configuration pour paiement en ligne.")
|
|
|
|
reponse_server_cashless = self.check_carte_serveur_cashless(carte.uuid)
|
|
if reponse_server_cashless.status_code == 200:
|
|
json_reponse = json.loads(reponse_server_cashless.json())
|
|
liste_assets = json_reponse.get('liste_assets')
|
|
email = json_reponse.get('email')
|
|
|
|
if json_reponse.get('history') :
|
|
for his in json_reponse.get('history') :
|
|
his['date'] = datetime.fromisoformat(his['date'])
|
|
|
|
return render(
|
|
request,
|
|
self.template_name,
|
|
{
|
|
'tarifs_adhesion': TarifsAdhesion.objects.all(),
|
|
'adhesion_obligatoire': configuration.adhesion_obligatoire,
|
|
'assets': json_reponse.get('assets'),
|
|
'total_monnaie': json_reponse.get('total_monnaie'),
|
|
'history': json_reponse.get('history'),
|
|
'carte_resto': configuration.carte_restaurant,
|
|
'site_web': configuration.site_web,
|
|
'image_carte': carte.detail.img,
|
|
'numero_carte': carte.number,
|
|
'client_name': carte.detail.origine.name,
|
|
'domain': sub_addr,
|
|
'informations_carte': reponse_server_cashless.text,
|
|
'liste_assets': liste_assets,
|
|
'email': email,
|
|
'billetterie_bool': configuration.activer_billetterie,
|
|
}
|
|
)
|
|
|
|
|
|
elif reponse_server_cashless.status_code == 400:
|
|
# Carte non trouvée
|
|
return HttpResponse('Carte inconnue', status=status.HTTP_400_BAD_REQUEST)
|
|
elif reponse_server_cashless.status_code == 403 :
|
|
# Clé api HS
|
|
logger.error(reponse_server_cashless)
|
|
return HttpResponse('Forbidden', status=status.HTTP_403_FORBIDDEN)
|
|
else :
|
|
return HttpResponse(f'{reponse_server_cashless.status_code}', status=reponse_server_cashless.status_code)
|
|
|
|
def post(self, request, uuid):
|
|
carte = check_carte_local(uuid)
|
|
if carte.detail.origine != connection.tenant:
|
|
raise Http404
|
|
|
|
|
|
data = request.POST
|
|
print(data)
|
|
# c'est une recharge
|
|
if data.get('montant_recharge') and data.get('email'):
|
|
# montant_recharge = data.get('montant_recharge')
|
|
montant_recharge = float("{0:.2f}".format(float(data.get('montant_recharge'))))
|
|
if montant_recharge > 0:
|
|
|
|
# reponse_server_cashless = self.check_carte_serveur_cashless(carte.uuid)
|
|
# configuration = Configuration.get_solo()
|
|
|
|
art, created = Article.objects.get_or_create(
|
|
name="Recharge Carte",
|
|
prix=1,
|
|
publish=False,
|
|
categorie_article=Article.RECHARGE_CASHLESS,
|
|
)
|
|
|
|
ligne_article = LigneArticle.objects.create(
|
|
article = art,
|
|
qty = montant_recharge,
|
|
)
|
|
|
|
metadata = {
|
|
'recharge_carte_uuid': str(carte.uuid),
|
|
'recharge_carte_montant': str(montant_recharge),
|
|
}
|
|
|
|
new_checkout_session = creation_checkout_stripe(
|
|
email_paiement = data.get('email'),
|
|
liste_ligne_article = [ligne_article,],
|
|
metadata = metadata,
|
|
absolute_domain = request.build_absolute_uri().partition('/qr')[0],
|
|
)
|
|
|
|
if new_checkout_session.is_valid() :
|
|
print(new_checkout_session.checkout_session.stripe_id)
|
|
return new_checkout_session.redirect_to_stripe()
|
|
|
|
# c'est la première étape de l'adhésion
|
|
elif data.get('email') \
|
|
and not data.get('prenom') \
|
|
and not data.get('prenom') \
|
|
and not data.get('tel') :
|
|
|
|
sess = requests.Session()
|
|
configuration = Configuration.get_solo()
|
|
r = sess.post(
|
|
f'{configuration.server_cashless}/api/billetterie_qrcode_adhesion',
|
|
headers={
|
|
'Authorization': f'Api-Key {configuration.key_cashless}'
|
|
},
|
|
data={
|
|
'email': data.get('email'),
|
|
'uuid_carte': carte.uuid,
|
|
})
|
|
|
|
sess.close()
|
|
|
|
# nouveau membre crée avec uniquqment l'email on demande la suite.
|
|
if r.status_code in (201, 204) :
|
|
messages.success(request, f"{data.get('email')}", extra_tags='email')
|
|
return HttpResponseRedirect(f'#demande_nom_prenom_tel')
|
|
|
|
#partial information :
|
|
elif r.status_code == 206:
|
|
partial = json.loads(r.text)
|
|
messages.success(request, f"{data.get('email')}", extra_tags='email')
|
|
if partial.get('name'):
|
|
messages.success(request, f"Email déja connu. Name déja connu", extra_tags='name')
|
|
if partial.get('prenom'):
|
|
messages.success(request, f"Email déja connu. prenom déja connu", extra_tags='prenom')
|
|
if partial.get('tel'):
|
|
messages.success(request, f"Email déja connu. tel déja connu", extra_tags='tel')
|
|
return HttpResponseRedirect(f'#demande_nom_prenom_tel')
|
|
else:
|
|
messages.error(request, f'Erreur {r.status_code} {r.text}')
|
|
return HttpResponseRedirect(f'#erreur')
|
|
|
|
# suite de l'adhesion
|
|
elif data.get('email') and data.get('name') and data.get('prenom') and data.get('tel'):
|
|
sess = requests.Session()
|
|
configuration = Configuration.get_solo()
|
|
r = sess.post(
|
|
f'{configuration.server_cashless}/api/billetterie_qrcode_adhesion',
|
|
headers={
|
|
'Authorization': f'Api-Key {configuration.key_cashless}'
|
|
},
|
|
data={
|
|
'prenom': data.get('prenom'),
|
|
'name': data.get('name'),
|
|
'email': data.get('email'),
|
|
'tel': data.get('tel'),
|
|
'uuid_carte': carte.uuid,
|
|
})
|
|
|
|
sess.close()
|
|
|
|
# nouveau membre crée, on demande la suite.
|
|
if r.status_code == 202 :
|
|
messages.success(request, f"Merci ! Membre créé et carte liée.")
|
|
|
|
return HttpResponseRedirect(f'#adhesionsuccess')
|
|
else :
|
|
messages.error(request, f'Erreur {r.status_code} {r.text}')
|
|
return HttpResponseRedirect(f'#erreur')
|
|
|
|
|
|
def postPaimentRecharge(paiementStripe: Paiement_stripe, request):
|
|
if paiementStripe.status == Paiement_stripe.PAID:
|
|
|
|
metadata_db_json = paiementStripe.metadata_stripe
|
|
metadata_db = json.loads(metadata_db_json)
|
|
uuid_carte = metadata_db.get('recharge_carte_uuid')
|
|
total_rechargement = metadata_db.get('recharge_carte_montant')
|
|
|
|
if uuid_carte and total_rechargement :
|
|
|
|
|
|
# on vérifie toujours que la carte vienne bien du domain et Client tenant.
|
|
carte = check_carte_local(uuid_carte)
|
|
if carte.detail.origine != connection.tenant:
|
|
logger.error(f"{timezone.now()} "
|
|
f"postPaimentRecharge {uuid_carte} : "
|
|
f"carte detail origine correspond pas : {carte.detail.origine} != {connection.tenant}")
|
|
raise Http404
|
|
|
|
sess = requests.Session()
|
|
configuration = Configuration.get_solo()
|
|
r = sess.post(
|
|
f'{configuration.server_cashless}/api/billetterie_endpoint',
|
|
headers={
|
|
'Authorization': f'Api-Key {configuration.key_cashless}'
|
|
},
|
|
data={
|
|
'uuid': uuid_carte,
|
|
'qty': float(total_rechargement),
|
|
'uuid_commande': paiementStripe.uuid,
|
|
})
|
|
|
|
sess.close()
|
|
|
|
logger.info(f"{timezone.now()} demande au serveur cashless pour un rechargement. réponse : {r.status_code} ")
|
|
print (f"{timezone.now()} demande au serveur cashless pour un rechargement. réponse : {r.status_code} ")
|
|
|
|
if r.status_code == 200:
|
|
# la commande a été envoyé au serveur cashless, on la met en validée
|
|
paiementStripe.status = Paiement_stripe.VALID
|
|
paiementStripe.save()
|
|
|
|
return HttpResponseRedirect(f'#success')
|
|
|
|
elif paiementStripe.status == Paiement_stripe.VALID:
|
|
messages.success(request, f"Le paiement a déja été validé.")
|
|
return HttpResponseRedirect(f'#historique')
|
|
|
|
return HttpResponseRedirect(f'#erreurpaiement')
|