def update_orders(self):
from core.services.payutc import PayutcClient
p = PayutcClient()
p.login_admin()
rep = p.get_sales(product_id__in=[self.article.id_payutc])
for line in rep['transactions']:
if line['status'] == 'V':
orderline, created = OrderLine.objects.get_or_create(id_transaction_payutc=line['id'],
defaults={"menu": self})
if created:
for payments in line['rows']:
orderline.id_rows_payutc = payments['id']
for menu in payments['payments']:
orderline.id_buyer = menu['buyer']['id']
orderline.quantity = menu['quantity']
orderline.buyer_first_name = menu['buyer']['first_name']
orderline.buyer_name = menu['buyer']['last_name']
orderline.save()
for line1 in line['rows']:
if line1['cancels']:
o = OrderLine.objects.filter(id_rows_payutc=line1['cancels']).first()
if o:
o.is_canceled = True
o.save()
buyers_list = list()
orders = OrderLine.objects.filter(menu_id=self.id, quantity__gt=0, is_canceled=False).order_by('served',
'is_staff',
'id_transaction_payutc')
for order in orders:
buyers_list.append(
{'last_name': order.buyer_name, 'first_name': order.buyer_first_name, 'quantity': order.quantity,
'served': order.served, 'is_staff': order.is_staff, 'id_transaction': order.id_transaction_payutc})
return buyers_list
def get_beers_sells(request):
"""
Obtention des ventes dans la journée courante des ids mis en paramètres
Méthode utilisée publique, utilisée pour le duel des brasseurs en A19
"""
beers = request.data['beers']
response = dict()
current_date = (datetime.now()).strftime('%Y-%m-%d')
start_date = current_date + "T00:00:01.000Z"
end_date = current_date + "T23:59:59.000Z"
p = PayutcClient()
p.login_admin()
duels = beers.keys()
for duel in duels:
response[duel] = dict()
duel_beers = beers[duel].keys()
for beer in duel_beers:
beer_id = beers[duel][beer]['id']
nb_sells = p.get_nb_sell(obj_id=beer_id,
start=start_date,
end=end_date)
response[duel][beer] = dict()
response[duel][beer]['id'] = beers[duel][beer]['id']
response[duel][beer]['quantity'] = nb_sells
return JsonResponse({'beers': response}, status=200)
def user_autocomplete(request, query, format=None):
"""Authenticate with badge_id"""
data = {'queryString': query}
sessionid = request.session['payutc_session']
p = PayutcClient()
p.login_admin()
return JsonResponse({'users': p.auto_complete(data)})
def set_article_disabled(self):
from core.services.payutc import PayutcClient
p = PayutcClient()
p.login_admin()
rep = p.patch_api_rest('resources',
'products',
self.id_payutc,
active=False)
return rep
def update_sales(self):
from core.services.payutc import PayutcClient
p = PayutcClient()
p.login_admin()
rep = p.get_nb_sell(obj_id=self.id_payutc)
self.ventes = rep
self.ventes_last_update = timezone.now()
self.save()
return self.ventes
def user_autocomplete(request, query, format=None):
"""
Récupération à parti d'une query string des utilisateurs
sur Payutc pouvant être susceptible de ressembler à la query
"""
data = {'queryString': query}
sessionid = request.session['payutc_session']
p = PayutcClient()
p.login_admin()
return JsonResponse({'users': p.auto_complete(data)})
def login_callback(request, format=None):
"""Try login via PayUTC with CAS ticket"""
ticket, service, redirection = _get_params(request)
payutc = PayutcClient()
# If login successfully, add info to session, redirect to the front
try:
resp = payutc.login_cas(ticket, service)
_set_session_information(request, resp['username'], resp['sessionid'])
return redirect(redirection)
# Else return error
except PayutcException as error:
return JsonResponse(error.response.json().get('error', {}),
status_code=status.HTTP_400_BAD_REQUEST)
def login_badge(request, format=None):
"""Authenticate with badge_id"""
request.session.flush()
body_content = request.data
badge_id = body_content["badge_id"]
pin = body_content["pin"]
p = PayutcClient()
resp = p.login_badge(badge_id=badge_id, pin=pin)
if(not _is_user_member(resp["username"])):
return JsonResponse({"error": "Vous n'êtes pas autorisé à effectuer cette action."}, status=403)
connexion_type = _get_connexion_type(request)
_set_session_information(request, resp['username'], resp['sessionid'], connexion_type)
request.session.set_expiry(2*3600)
return JsonResponse(resp, status=200)
def tva_info(request, id):
"""Obtention des informations de la tva"""
periode = core_models.PeriodeTVA.objects.get(pk=id)
# Pour la TVA déductible : on veut juste obtenir le montant total de TVA
tva_deductible = sum([
facture.get_total_taxes()
for facture in treso_models.FactureRecue.objects.filter(
date__gte=periode.debut, date__lte=periode.fin)
])
# Pour la TVA à déclarer :
# * On récupère toute la TVA sur PayUTC pendant cette période.
# * On récupère toute la TVA sur les factures émises pendant cette période.
# Event_id hardcoded to 1
sessionid = request.session['payutc_session']
p = PayutcClient(sessionid)
sales = p.get_export(start=periode.debut.isoformat(),
end=periode.fin.isoformat(),
event_id=1)
payutc_tva_types = set(sale['pur_tva'] for sale in sales)
factures_emises = treso_models.FactureEmiseRow.objects.prefetch_related(
'facture').filter(facture__date_creation__gte=periode.debut,
facture__date_creation__lte=periode.fin)
tva_types = payutc_tva_types.union(
set(facture.tva for facture in factures_emises))
tva_a_declarer = list()
for tva_type in tva_types:
tva_a_declarer.append({
'pourcentage':
tva_type,
'montant':
sum([(1 - (100 / (100 + sale['pur_tva']))) * sale['total'] * 0.01
for sale in sales if sale['pur_tva'] == tva_type]) +
sum(facture.get_total_taxes() * facture.qty
for facture in factures_emises if facture.tva == tva_type)
})
return JsonResponse({
'tva_deductible':
tva_deductible,
'tva_a_declarer':
tva_a_declarer,
'tva_a_declarer_total':
sum(tva['montant'] for tva in tva_a_declarer)
})
def create(self, request):
"""Méthode pour générer 20 vainqueurs des goodies parmis les non-membres du Pic"""
# Récupération des ventes entre une date de début et une date de fin
# START doit être au format "AAAA-MM-JJ"
# END doit être au format "AAAA-MM-JJ"
# ROW_COUNT représente le nombre maximum de ventes récupérées
sessionid = request.session['payutc_session']
p = PayutcClient()
p.login_admin()
start = request.data['start_date'] + "T00:00:01.000Z"
end = request.data['end_date'] + "T23:00:00.000Z"
ROW_COUNT = 20000
sales = p.get_sales(start=start, end=end,
row_count=ROW_COUNT)['transactions']
# Recherche des membres dans le Pic actuel
pic_members = []
queryset = core_models.UserRight.objects.filter(
Q(right='A') | Q(right='M'))
serializer = core_serializers.UserRightSerializer(queryset, many=True)
# Récupération des logins des membres du Pic pour les supprimer par la suite de la génération
for i, user in enumerate(serializer.data):
login = serializer.data[i]['login']
pic_members.append(login)
# Récupération aléatoire d'utilisateurs
goodies_winners = []
nb_sales = len(sales)
while (len(goodies_winners) < 20):
# Tant qqu'on a pas 20 vainqueurs on itère
random_value = random.randint(1, nb_sales)
user = sales[int(random_value) -
1]['rows'][0]['payments'][0]['buyer']
user_description = user["first_name"] + " " + user["last_name"]
# Si l'utilisateur n'est pas un membre du Pic ou un login déjà dans la liste des vainqueurs, ajout
if (user["username"] not in pic_members
and user_description not in goodies_winners):
goodies_winners.append(user_description)
payutc_models.GoodiesWinner.objects.create(
winner=user_description, picked_up=False)
# Renvoi des données
queryset = payutc_models.GoodiesWinner.objects.all()
serializer = payutc_serializers.GoodiesWinnerSerializer(queryset,
many=True)
return JsonResponse({'winners': serializer.data})
def login_badge(request, format=None):
"""Authenticate with badge_id"""
body_content = request.data
badge_id = body_content["badge_id"]
pin = body_content["pin"]
p = PayutcClient()
resp = p.process_request("login",
"badge",
params={
"badge_id": badge_id,
"pin": pin
})
_set_session_information(request, resp['username'], resp['sessionid'])
request.session.set_expiry(2 * 3600)
return JsonResponse(resp, status=200)
def get_articles(request, format=None):
p = PayutcClient()
articles = p.get_articles()
if (request.GET.get('sorted')):
sorted_articles = {
3: ('softs', []),
11: ('bieresPression', []),
10: ('bieresBouteille', []),
9: ('snacksSucres', []),
17: ('snacksSales', []),
184: ('glace', []),
221: ('petitDej', []),
199: ('pampryls', []),
}
for article in articles:
# IDs des catégories
# ==================
# Softs : 3
# Bières pression : 11
# Bières bouteille : 10
# Snacks sucrés : 9
# Snacks salés : 17
# Glacé : 184
# Petit dej : 221
# Pampryls : 199
if (article["active"]):
bin = sorted_articles.get(article["categorie_id"])
if bin is not None:
bin[1].append({
'name': article["name"],
'price': article["price"]
})
return Response(dict(sorted_articles.values()))
return Response(articles)
def login_username(request, format=None):
"""Authenticate with username and pin"""
body_content = request.data
username = body_content["username"]
pin = body_content["pin"]
ginger = GingerClient()
ginger_response = ginger.get_user_info(username)
badge_id = ginger_response['data']['badge_uid']
p = PayutcClient()
resp = p.process_request("login",
"badge",
params={
"badge_id": badge_id,
"pin": pin
})
_set_session_information(request, resp['username'], resp['sessionid'],
'menu')
request.session.set_expiry(2 * 3600)
return JsonResponse(resp, status=200)
def create_payutc_article(self):
if self.id_payutc:
return self.id_payutc
from core.services.payutc import PayutcClient
p = PayutcClient()
p.login_admin()
data = {
'active': True,
'alcool': False,
'cotisant': True,
'name': self.nom + ' - ' + self.creneau.perm.nom,
'parent': PAYUTC_ARTICLES_CATEGORY,
'prix': int(self.prix * 100),
'stock': self.stock,
'tva': self.tva,
'variable_price': False
}
res = p.set_product(data)
self.id_payutc = int(res['success'])
self.ventes_last_update = timezone.now()
self.save()
Menu.objects.create(article=self)
return self.id_payutc
def make_shotgun(self, request, max):
p = PayutcClient()
p.login_admin()
data_temp = request.data.copy()
liste = p.auto_complete({'queryString': request.data['login']})
if len(liste) == 1:
data_temp['email'] = liste[0]['email']
nbListe = shotgun_models.Creneau.objects.select_related(
'user').filter(userinshotgun__id_creneau=request.
data['id_creneau']).count()
if nbListe < max:
serializer = self.get_serializer(data=data_temp)
serializer.is_valid(raise_exception=True)
self.perform_create(serializer)
headers = self.get_success_headers(serializer.data)
return Response({"Success": "shotgun réalisé"},
status=200,
headers=headers)
else:
return Response({"Fail": "maximim de personnes déjà atteint"},
status=429)
else:
return Response({"Fail": "votre login est invalide"}, status=422)
def login_badge(request, format=None):
p = PayutcClient()
