def get(self, request):
order_pk = request.session['order_pk']
order_payment = OrderPayment.objects.get(order_pk=order_pk)
payment_id = request.data['object']['id']
Payment.capture(payment_id)
order = Order.objects.get(pk=order_pk)
order_products = order.products.all()
order_products.update(is_ordered=True)
for product in order_products:
product.save()
order.is_ordered = True
#order.payment = payment
order.payment.charge_id = payment_id
order.save()
return Response(status=200)
def create_payment(self, data):
"""
Создать платёж.
"""
payment = Payment.create(data, self.generate_idempotence_key())
# TODO: Сделать специальный класс для данной ошибки и описание.
payment_status = payment.status
if payment_status not in PaymentStatus.available_choices():
raise YandexKassaException()
# TODO: Сделать специальный класс для данной ошибки и описание.
payment_payment_method = payment.payment_method.type
if payment_payment_method not in PaymentMethod.available_choices():
raise YandexKassaException()
data = {
'amount': payment.amount.value,
'confirmation_url': payment.confirmation.confirmation_url,
'created_at': dateparse.parse_datetime(payment.created_at),
'currency': payment.amount.currency,
'metadata': payment.metadata,
'payment_id': payment.id,
'payment_method': payment_payment_method,
'status': payment_status,
}
if payment.description:
data['description'] = payment.description
return data
def get(self, request, value=3000, id=None):
Configuration.account_id = '718911'
Configuration.secret_key = 'test_LvcNnzMH8UOAI0Rc6Dw7MvP8O6WAZoQwsF0kW7e5tY4'
print(id)
nmb = int(value / 3000)
currency = "RUB"
return_url = "https://chestnokfest.live/tickets/payment_redirect/"
description = str("Покупка " + str(nmb) + " билета(ов) за " +
str(value))
payment = Payment.create({
"amount": {
"value": value,
"currency": currency
},
"confirmation": {
"type": "redirect",
"return_url": return_url
},
"description": description,
"metadata": {
'id': id,
}
})
return HttpResponseRedirect(payment.confirmation.confirmation_url)
def payment_status(self, payment_id):
"""
Получить информацию о платеже.
"""
payment = Payment.find_one(payment_id)
created_at = (dateparse.parse_datetime(payment.created_at)
if payment.created_at else None)
captured_at = (dateparse.parse_datetime(payment.captured_at)
if payment.captured_at else None)
expires_at = (dateparse.parse_datetime(payment.expires_at)
if payment.expires_at else None)
return {
'amount': payment.amount.value,
'captured_at': captured_at,
'created_at': created_at,
'currency': payment.amount.currency,
'description': payment.description,
'expires_at': expires_at,
'metadata': payment.metadata,
'payment_method': payment.payment_method.type,
'receipt_registration': payment.receipt_registration,
'status': payment.status,
}
def post(self, request):
print(request.data)
pay_id = request.data.get('pay_id')
Configuration.account_id = settings.YA_SHOP_ID
Configuration.secret_key = settings.YA_API
paymentObj = PaymentObj.objects.get(pay_code=pay_id)
print(paymentObj)
if not paymentObj.is_payed:
payment = Payment.find_one(paymentObj.pay_id)
print(payment)
if payment.status == 'succeeded':
paymentObj.is_payed = True
paymentObj.status = 'Оплачен'
paymentObj.save()
paymentObj.user.balance += paymentObj.amount
paymentObj.user.save(force_update=True)
all_refferals = Refferal.objects.filter(refferal=paymentObj.user)
print(all_refferals)
if all_refferals.exists():
for reffreal in all_refferals:
print(reffreal.master)
reffreal.master.partner_balance += int(paymentObj.amount *
10 / 100)
reffreal.master.save()
reffreal.earned += int(paymentObj.amount * 10 / 100)
reffreal.save()
return Response(status=200)
def get(self, request):
uuid = request.session.pop('payment') if 'payment' in request.session else None
payment = None
if uuid is not None:
payment = models.Payment.objects.filter(uuid=uuid).first()
if payment:
payment_id = payment.yuid
log = models.Logging.objects.create(
action="Запрос данных в Яндекс кассе для ReturnUrl после оплаты. api/views.PaymentReturnUrl.get()",
input_data=f"yuid: {payment_id}")
try:
payment_info = Payment.find_one(payment_id)
except Exception as err:
log.result = log.FAIL
log.output_data = f"{err}"
log.save()
else:
if payment.status != payment_info.status:
payment.status_set(payment_info.status)
# models.Payment.objects.filter(pk=payment.pk).update(status=payment_info.status)
# payment.status = payment_info.status
# if payment_info.status == 'succeeded':
# payment.date_approve = timezone.now()
# payment.save()
log.result = log.SUCCESS
try:
payment_info_dict = {key: value.__dict__ if isinstance(value, BaseObject) else value for key, value
in payment_info.__dict__.items()}
log.output_data = f"{payment_info_dict}"
except:
log.output_data = f"{payment_info}"
log.save()
form_html = get_template('includes/payment_info.html').render(context={'payment': payment}, request=request)
context = self.make_context(content=form_html, title='Статус платежа')
return render(request, 'general.html', context=context)
async def buy_course(user_id, course_id, redirect_url):
course = await CourseModel.get(course_id)
if course.cost is None or course.cost <= 0:
await PurchasedCoursesModel.create(
course_id=course_id,
user_id=user_id
)
return None
payment = Payment.create({
"amount": {
"value": '{:.2f}'.format(course.cost),
"currency": "RUB"
},
"confirmation": {
"type": "redirect",
"return_url": redirect_url
},
"capture": True,
"description": "Покупка курса {name}".format(name=course.name)
}, uuid.uuid4())
await PaymentModel.create(
user_id=user_id,
course_id=course_id,
order_id=payment.id
)
return payment.confirmation.confirmation_url
def createPayment(self,user,amount,booking=None,payment_type="account"):
'''
Create yandex kassa payment object. payment_type = True - autopayment otherwise is add card
'''
if self.getCurrentTransaction(user,amount,booking,payment_type) is not None:
print("Yes getCurrentTransaction")
return self.getCurrentTransaction(user,amount,booking,payment_type).getInfo()
payment_info = {
"amount": {
"value": str(decimal.Decimal(amount)),
"currency": "RUB"
},
"description": "Привязка карты"
}
payment_info.update(self.createReceipt(user,amount))
if payment_type == "full":
payment_info.update(self.createAutoPayment(user))
else: #payment_type == "account": # False
payment_info.update(self.createConfirmation())
payment_object = Payment.create(payment_info)
self.create(
user = user,
booking = booking,
price = amount,
date = now(),
status = payment_object.status,
payment_type = payment_type,
payment_id = payment_object.id,
created_at = payment_object.created_at,
expires_at = payment_object.expires_at,
checkouted = False
)
return payment_object
def pay_without_payment_id(self, order, value):
return_url = f"{self.site_url}pay/{order.id}/"
payment = Payment.create(
{
"amount": {
"value": value,
"currency": "RUB"
},
"capture": True,
"payment_method_data": {
"type": "bank_card"
},
"confirmation": {
"type": "redirect",
"return_url": return_url
},
"description": f"Заказ {order.id}",
"save_payment_method": True,
"metadata": {
"order_id": order.id
}
}, str(uuid.uuid4()))
return payment
def get(self, request):
with open('/Users/blockbusted/PycharmProjects/config_shop_file.json') as config_file:
config = json.load(config_file)
Configuration.account_id = config['YANDEX_SHOP_ID']
Configuration.secret_key = config['YANDEX_SECRET_KEY']
order_pk = self.request.session['order_pk']
order = Order.objects.get(pk=order_pk)
amount = order.get_total_order_price()
idempotence_key = str(uuid.uuid4())
payment = Payment.create({
# "payment_token": idempotence_key,
"amount": {
"value": 1,
"currency": "RUB"
},
"confirmation": {
"type": "redirect",
"return_url": "cart:payment-yandex-notifications"
},
"description": "Заказ №"+str(order_pk)
})
order_payment = OrderPayment()
order_payment.order_pk = order_pk
if self.request.user.is_authenticated:
order_payment.user = self.request.user
order_payment.amount = amount
order_payment.save()
return HttpResponseRedirect(payment.confirmation.confirmation_url)
def pay(value, order_id, email, items, delivery):
Configuration.account_id = settings.YA_ACCOUNT_ID
Configuration.secret_key = settings.YA_SECRET_KEY
payment_items = [
{"description": f'{item.item.title} [{item.size.title}]', "quantity": "1",
"amount": {"value": item.item.price, "currency": "RUB"},
"vat_code": 1} for item in items]
if delivery:
payment_items += [{"description": "Доставка", "quantity": "1", "amount": {"value": delivery, "currency": "RUB"},
"vat_code": 1}]
payment = Payment.create({
"amount": {
"value": value,
"currency": "RUB"
},
"confirmation": {
"type": "embedded",
"return_url": "https://test.hrsmnt.ru/#/"
},
"receipt": {
"customer": {
"email": email,
},
"items": payment_items
},
"capture": True,
"description": f"Заказ №{order_id}"
}, uuid.uuid4())
return payment.confirmation.confirmation_token, payment.id
def payment_formation(order):
Configuration.account_id = settings.YANDEX_SHOP_ID
Configuration.secret_key = settings.YANDEX_SECRET_KEY
independent_key = str(uuid.uuid4())
payment = Payment.create(
{
"amount": {
"value": order.amount,
"currency": "RUB"
},
"confirmation": {
"type": "redirect",
"return_url": "https://expertsovet.com"
},
"receipt": {
"email":
order.email,
"payment_subject":
order.good.payment_subject,
"payment_mode":
order.good.payment_mode,
"items": [{
"description": order.good.subtitle[:128],
"quantity": 1,
"amount": {
"value": order.amount,
"currency": "RUB"
},
"vat_code": "1",
}]
},
"description": f"Заказ №{order.id}"
}, independent_key)
return payment
def yandex_confirm(request):
if request.method == 'POST':
response_json = json.loads(request.body)
data = response_json['object']
if data['status'] == 'waiting_for_capture':
payment_id = response_json['object']['id']
data = Payment.capture(payment_id)
# если платеж ожидает подтверждения, подтверждаю
model = PaymentInfo()
elif data['status'] == 'succeeded':
model = PaymentInfo()
else:
pass
try:
model.payment_id = data['id']
# id платежа из яндекс кассы
model.phone = '+' + ''.join(re.findall(r'\d', data['description']))
# привожу + 7 (900) 00-000-00 к +79000000000
model.money = int(float(data['amount']['value']))
# привожу строку 100.00 к цыфре 100
model.paid = True
model.save_with_bonus()
mount = str(model.money + model.count_bonus(model.money))
# Привожу сумму + бонус к строке для передачи в апи
continue_play(model.phone, mount,
1) # last argument it's time in hours
status = 200
except:
status = 200
return HttpResponse(status=status)
def post(self, request):
Configuration.account_id = '718911'
Configuration.secret_key = 'test_LvcNnzMH8UOAI0Rc6Dw7MvP8O6WAZoQwsF0kW7e5tY4'
payment_id = request.data['object']['id']
Payment.capture(payment_id)
order_id = request.data['object']['metadata']['id']
order = PaymentModel.objects.get(id=order_id)
tickets = TicketPay.objects.all()
send_email = False
gen_codes = []
render_tickets = []
for ticket in tickets:
if ticket.order == order:
if not ticket.is_saved:
print(ticket.is_payed)
ticket.is_payed = True
ticket.is_saved = True
ticket.save()
send_email = True
email = ticket.email
gen_codes.append(ticket.generated_code)
render_tickets.append(ticket)
print(ticket.is_payed)
if send_email:
gen_codes = ' '.join(gen_codes)
print(gen_codes)
print(email)
context = {
'tickets': render_tickets,
}
# print(context['tickets'][0])
send_mail('Ваш заказ с билетом(ами)',
gen_codes,
'*****@*****.**', [email],
html_message=get_template('Payment/letter.html').render(
context))
# send_mail('Ваш заказ с билетом(ами)', gen_codes, '*****@*****.**', [email])
# нужно забрать айдишники, за которые заплачено и привязать тут полю is_payed значение True
# после отправить на мыло ключ с инфой
# otpravka email s klyu4om
return Response(status=200)
def post(self, request):
"""
Подтверждение платежа и смена статуса заказа
:param request:
:return:
"""
order_id = request.GET.get("order_id", "")
order = Orders.objects.get(id=order_id)
payment_id = order.payment_id
# payment_id = '26fd1b35-000f-5000-a000-14c3cdc3d6c1'
Payment.capture(payment_id)
order = Orders.objects.get(id=order_id)
order.status_order = 3
order.save()
return Response(status=200)
def post(self, *args, **kwargs):
Configuration.account_id = settings.YANDEX_ACCOUNT_ID
Configuration.secret_key = settings.YANDEX_SECRET_KEY
user = self.request.user
try:
game = Game.objects.get(pk=kwargs.get('pk'))
except Game.DoesNotExist:
return Response({
'error': 'Game does not exist!',
},
status=status.HTTP_400_BAD_REQUEST)
user_registered_places = UserInTeam.objects.filter(game=game.pk,
user=user.pk)
if user_registered_places.count() == 0:
return Response(
{
'error': 'User has no purchased seats for this game!',
},
status=status.HTTP_400_BAD_REQUEST)
user_game_payments = GamePayment.objects.filter(user=user.pk,
game=game.pk,
status='SUCCEEDED')
if user_game_payments.count() == 0:
return Response(
{
'error': 'User has no successful payments for this game!',
},
status=status.HTTP_400_BAD_REQUEST)
refunds = []
non_refundable_payments = []
unregistered_places_count = 0
for game_payment in user_game_payments:
payment = Payment.find_one(game_payment.identifier)
if payment.status == 'succeeded':
game_payment_refund = create_refund(game_payment, user, game)
refunds.append(game_payment_refund)
if game_payment_refund.status == 'SUCCEEDED':
del_objects = UserInTeam.objects.filter(
game=game.pk, user=user.pk)[:game_payment.places_count]
for del_object in del_objects:
del_object.delete()
unregistered_places_count += game_payment.places_count
else:
non_refundable_payments.append(game_payment)
if len(refunds):
create_timeline_block('GAME_MESSAGE',
settings.USER_CANCEL_REGISTRATION, user,
'APP', game)
return Response(
{
'refunds':
GamePaymentRefundSerializer(refunds, many=True).data,
'non_refundable_payments':
GamePaymentSerializer(non_refundable_payments, many=True).data,
'unregistered_places_count':
unregistered_places_count,
},
status=status.HTTP_200_OK)
def capture(self):
return Payment.capture(
self.payment_id,
{"amount": {
"value": self.price,
"currency": "RUB"
}},
str(uuid.uuid4()) #idempotence key
)
def pay_with_payment_id(self, order, value):
payment = Payment.create(
{
"amount": {
"value": value,
"currency": "RUB"
},
"description": f"Заказ {order.id}",
"payment_method_id": self.payment_id
}, str(uuid.uuid4()))
return payment
def check_pay(self, payment_id):
paid = False
time_while_end = datetime.now() + timedelta(seconds=33)
while paid == False and datetime.now(tz=None) <= time_while_end:
payment_result = Payment.find_one(payment_id)
paid = payment_result.paid
time.sleep(3)
if paid:
paid = payment_result
return paid
def do_payment(track_code):
ad = Ads.query.filter_by(track=track_code).first()
form = ProcessPayment()
if current_user.is_authenticated:
user = Users.query.get(current_user.id)
if ad in user.ads.all():
is_own = True
else:
is_own = False
else:
is_own = False
if form.validate_on_submit() and form.submit.data:
Configuration.account_id = Variables.query.get(3).value
Configuration.secret_key = Variables.query.get(4).value
print(form.waste.data)
payment = Payment.create(
{
"amount": {
"value":
int(ad.price) - int(current_user.collected_m)
if form.waste.data else ad.price,
"currency":
"RUB"
},
"confirmation": {
"type": "redirect",
"return_url": "https://vk.com/id608742663"
},
"capture": True,
"description": "Оплата объявления {}".format(ad.track),
"metadata": {
"track": ad.track,
"bonus_used": 1 if form.waste.data else 0,
"payer": current_user.id if is_own else 'unregistered user'
}
}, uuid.uuid4())
print('передано в оплату')
return redirect(payment.confirmation.confirmation_url)
return render_template('do_payment.html',
form=form,
ad=ad,
is_own=is_own,
current_user=current_user,
price_btn_text='Оплатить {}₽'.format(ad.price))
def handle_payment(self, order_number, total, **kwargs):
"""
Called from submit method
Handle any payment processing and record payment sources and events.
This method is designed to be overridden within your project.
This method is responsible for handling payment and recording the
payment sources (using the add_payment_source method) and payment
events (using add_payment_event) so they can be
linked to the order when it is saved later on.
"""
method = self.checkout_session.payment_method()
if method == 'cod':
source_type, is_created = models.SourceType.objects.get_or_create(
name='cash')
redirect_url = ''
elif method == 'yandex_kassa':
Configuration.account_id = settings.KASSA_ID
Configuration.secret_key = settings.KASSA_TOKEN
source_type, is_created = models.SourceType.objects.get_or_create(
name='online')
payment = Payment.create(
{
"amount": {
"value": str(total.incl_tax),
"currency": "RUB"
},
"confirmation": {
"type": "redirect",
"return_url":
"http://127.0.0.1:8000/checkout/thank-you/"
},
"capture": True, # холдирование - False
"description": order_number
},
uuid.uuid4())
redirect_url = payment.confirmation.confirmation_url
source = source_type.sources.model(source_type=source_type,
amount_allocated=total.incl_tax,
currency=total.currency)
self.add_payment_source(source)
self.add_payment_event('Authorised', total.incl_tax)
if redirect_url:
# return redirect(redirect_url)
raise RedirectRequired(redirect_url)
def pay(request, timeslot_id):
amount = 3400
timeslot = TimeSlot.objects.get(pk=timeslot_id)
user = create_user(request)
enroll = Enroll.objects.create(timeslot_id=timeslot_id, user=user, )
enroll.save()
payment = Payment.objects.create(enroll=enroll, status="initial", amount=amount, )
payment.save()
yandex_payment = YandexPayment.create({
"amount": {
"value": amount,
"currency": "RUB"
},
"payment_method_data": {
"type": "bank_card"
},
"confirmation": {
"type": "redirect",
"return_url": settings.KASSA_REDIRECT_URL
},
"capture": False,
"description": "Консультация " + timeslot.specialist.middle_name + " " + timeslot.specialist.first_name,
"receipt": {
"items": [{
"description": "Консультация " + timeslot.specialist.middle_name + " " + timeslot.specialist.first_name,
"quantity": 1,
"amount": {
"value": amount,
"currency": "RUB"
},
"vat_code": 1,
"payment_subject": "service",
"payment_mode": "full_prepayment"
}],
"tax_system_code": 3,
"email": user.email,
}
}, uuid.uuid4())
payment_id = yandex_payment.id
payment.yandex_payment = payment_id
payment.save()
print(yandex_payment)
return HttpResponseRedirect(yandex_payment.confirmation.confirmation_url)
def pay_notification(request):
payment_id = request.data['object']['id']
yandex_payment = YandexPayment.capture(payment_id)
payment = Payment.objects.get(yandex_payment=payment_id)
if payment:
payment.status = yandex_payment.status
payment.save()
print(yandex_payment.id)
print(yandex_payment.status)
user = payment.enroll.user
if not payment.notify:
payment.notify = True
payment.save()
pay_user_email_notify(payment)
pay_specialist_email_notify(payment)
return Response(status=200)
def paycheck(request, payment_id):
order = get_object_or_404(UserAccount, key=payment_id)
payment = Payment.find_one(order.payment_id)
if payment.status == "succeeded":
order.status = True
order.save()
try:
send_mail(
'Алгоритм языка | Оплата занятий',
'Вы успешно оплатили заказ № {0} на сумму: {1}'.format(
order.pk, str(decimal.Decimal(order.price))),
'*****@*****.**',
['{0}'.format(order.email)],
fail_silently=False,
)
except Exception as e:
print("Email sendr exception {0}".format(e))
return render(request, "sprache/success.html", {"number": order.pk})
def createPaymentObject(self, capture=False, save_payment_method=True):
'''
Returns Yandex Kassa Object if rentor i.e user and price are set.
'''
if self.rentor is None:
return None
if self.price is None:
return None
return Payment.create({
"amount": {
"value": "{0}".format(str(decimal.Decimal(self.price))),
"currency": "RUB"
},
"confirmation": {
"type": "embedded"
},
"receipt": {
"customer": {
"full_name":
"{0} {1}".format(self.rentor.first_name,
self.rentor.last_name),
"email":
"{0}".format(self.rentor.email)
},
"items": [{
"description": "Оплата аренды",
"quantity": "2.00",
"amount": {
"value":
"{0}".format(str(decimal.Decimal(self.price))),
"currency": "RUB"
},
"vat_code": "2",
"payment_mode": "full_prepayment",
"payment_subject": "commodity"
}]
},
"capture":
capture,
"save_payment_method":
save_payment_method,
"description":
"Оплата аренды №{0}".format(self.pk)
})
def refresh_payment(payment):
Configuration.configure(settings.YANDEX_CHECKOUT_CLIENT_ID,
settings.YANDEX_CHECKOUT_SECRET_KEY)
yandex_payment = YandexPayment.find_one(payment.yandex_id)
need_to_set_payed = False
if payment.status == Payment.PENDING and yandex_payment.status in (
Payment.WAITING_FOR_CAPTURE, Payment.SUCCEEDED):
need_to_set_payed = True
payment.status = yandex_payment.status
if yandex_payment.cancellation_details:
payment.cancellation_reason = yandex_payment.cancellation_details.reason
payment.save(update_fields=['status', 'cancellation_reason'])
if need_to_set_payed:
set_order_payed(payment.order)
return payment
def create_payment(price, days):
payment = Payment.create({
"amount": {
"value": f"{price}",
"currency": "RUB"
},
"confirmation": {
"type": "redirect",
"return_url": "http://localhost:3000/pay_success"
},
"capture": True,
"description": "Заказ №1",
'metadata': {
'days': days
}
})
p_id = payment.id
print(p_id)
return payment.confirmation.confirmation_url, p_id
def index_page(request):
if request.method == 'POST':
form = PaymentInfoForm(request.POST)
if form.is_valid():
payment = Payment.create(
{
"amount": {
"value": form.cleaned_data['money'],
"currency": "RUB"
},
"confirmation": {
"type": "redirect",
"return_url": settings.ALLOWED_HOSTS[0]
},
"receipt": {
"customer": {
"full_name":
"ФИО",
"phone":
''.join(
re.findall(r'\d', form.cleaned_data['phone']))
},
"items": [{
"description": "Оплата бронирования",
"quantity": "1.00",
"amount": {
"value": form.cleaned_data['money'],
"currency": "RUB"
},
"vat_code": "2",
"payment_mode": "full_prepayment",
"payment_subject": "commodity"
}]
},
"capture": True,
"description": form.cleaned_data['phone']
}, uuid.uuid4())
return HttpResponseRedirect(payment.confirmation.confirmation_url)
else:
form = PaymentInfoForm()
return render(request, 'index.html', {'form': form})
def create_yandex_payment(self, user):
payment_data = {
'amount': {'value': self.cost, 'currency': 'RUB'},
'confirmation': {'type': 'redirect', 'return_url': 'https://sample-shop.com/'},
'capture': True,
'description': self.__str__(),
'receipt': {
'customer': {'email': user.email},
'items': [
{
'description': item.name,
'quantity': item.count,
'amount': {'value': item.price, 'currency': 'RUB'},
'vat_code': 1,
}
for item in self.order.items.all()
],
},
}
return YandexPayment.create(payment_data, self.inner_key)
def check_payment_status():
"""
периодическая проверка неконечных статусов платежа, с момента создания которых прошел час
(в течении часа пользователю доступен виджет оплаты в статусе -pending-)
"""
payments = models.Payment.objects.filter(
account__isnull=False,
yuid__isnull=False).exclude(status__in=['succeeded', 'canceled'])
if payments:
try:
upper_settings = models.UpperSetting.objects.get()
test = upper_settings.test_mode
if test:
yandex_api_key = upper_settings.yandex_api_key_test
shopid = upper_settings.shopid_test
else:
yandex_api_key = upper_settings.yandex_api_key
shopid = upper_settings.shopid
except:
base_dir = settings.BASE_DIR
env = environ.Env()
env.read_env(path.join(base_dir, '.env'))
yandex_api_key = env('YANDEX_API_KEY')
shopid = env('SHOPID')
Configuration.account_id = shopid
Configuration.secret_key = yandex_api_key
for payment in payments:
try:
payment_info = Payment.find_one(payment.yuid)
if payment.status != payment_info.status:
payment.status_set(payment_info.status)
# models.Payment.objects.filter(pk=payment.pk).update(status=payment_info.status)
# payment.status = payment_info.status
# if payment_info.status == 'succeeded':
# payment.date_approve = timezone.now()
# payment.save()
except Exception as ex:
print(ex)
