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 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 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)
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 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 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(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 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 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 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 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 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 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 payPrice(self):
if self.rentor is None:
print("r")
return None
if self.price is None:
print("p")
return None
if self.payment_type != 2:
print("pt")
return None
if self.status is True:
print("s")
return None
return Payment.create({
"amount": {
"value": self.renta.getPrice(),
"currency": "RUB"
},
"capture": "true",
"payment_method_id": self.rentor.usersdocuments.yakey,
"description": "Заказ ID:{0}".format(self.pk)
})
def get(self, type_id):
"""
Принимаем payment_id [GET]
Создаем платеж
Меняем статус платежа
Сохраняем
:param request:
:param format:
:return:
"""
order_id = self.request.GET.get('order_id')
order = Orders.objects.get(id=order_id)
# status = int(order.status_order)
value = order.order_price
payment = Payment.create(
{
"amount": {
"value": value,
"currency": "RUB"
},
"confirmation": {
"type": "redirect",
"return_url": "{}".format(config.url)
},
"capture": "false",
"description": "Заказ №{}".format(order_id),
"metadata": {
"order_id": "37"
}
}, uuid.uuid4())
# get confirmation url
confirmation_url = payment.confirmation.confirmation_url
order.payment_id = payment.id
order.status_order = 2
order.save()
return HttpResponseRedirect(confirmation_url)
def post(self, request):
print(request.data)
amount = request.data.get('amount')
payment_type = request.data.get('pay_type')
Configuration.account_id = settings.YA_SHOP_ID
Configuration.secret_key = settings.YA_API
pay_id = uuid.uuid4()
payment = Payment.create(
{
"amount": {
"value": amount,
"currency": "RUB"
},
"payment_method": {
"type": payment_type,
},
"confirmation": {
"type":
"redirect",
"return_url":
f'{settings.HOST}/profile/balance?pay_id={pay_id}'
},
"capture":
True,
"description":
f'Пополнение баланса пользователя ID {request.user.id}. {request.user.get_full_name()}'
}, pay_id)
pt = PaymentType.objects.get(method=payment_type)
PaymentObj.objects.create(user=request.user,
pay_id=payment.id,
pay_code=pay_id,
amount=int(amount),
type=pt,
status='Не оплачен')
return Response(payment.confirmation.confirmation_url)
def pay(request, payment_id):
order = get_object_or_404(UserAccount, key=payment_id)
payment = Payment.create({
"amount": {
"value": "{0}".format(str(decimal.Decimal(order.price))),
"currency": "RUB"
},
"confirmation": {
"type": "embedded"
},
"receipt": {
"customer": {
"full_name": "{0} {1}".format(order.first_name,
order.last_name),
"email": "{0}".format(order.email)
},
"items": [{
"description": "Оплата занятий",
"quantity": "2.00",
"amount": {
"value": "{0}".format(str(decimal.Decimal(order.price))),
"currency": "RUB"
},
"vat_code": "2",
"payment_mode": "full_prepayment",
"payment_subject": "commodity"
}]
},
"capture": True,
"description": "Заказ №{0}".format(order.pk)
})
order.payment_id = payment.id
order.save()
return render(request, "sprache/pay.html", {
"payment": payment,
"order": order
})
def create_payment(order):
Configuration.configure(settings.YANDEX_CHECKOUT_CLIENT_ID,
settings.YANDEX_CHECKOUT_SECRET_KEY)
idempotence_key = str(uuid.uuid4())
yandex_payment = YandexPayment.create(
{
'amount': {
'value': str(order.total_cost),
'currency': 'RUB',
},
'description': f'Платеж по заказу {order.id}',
'confirmation': {
'type': 'embedded'
}
}, idempotence_key)
payment = Payment.objects.create(
order=order,
yandex_id=yandex_payment.id,
status=yandex_payment.status,
amount=yandex_payment.amount.value,
currency=yandex_payment.amount.currency,
confirmation_token=yandex_payment.confirmation.confirmation_token)
return payment
def charge(self,
value: str,
currency: str,
description: str,
save_payment_method: bool = None) -> [str, str]:
"""
Make a payment request to Yandex Checkout.
"""
# todo: correct error handling
try:
payment_response = Payment.create({
"amount": {
"value": value,
"currency": currency,
},
"confirmation": {
"type": "redirect",
"return_url": settings.
YANDEX_CHECKOUT_RETURN_URL # replace with user's orders page
},
"capture":
True,
"description":
description,
"save_payment_method":
save_payment_method
})
except UnauthorizedError:
raise UnauthorizedError("Set Yandex Checkout keys in env vars.")
payment_response = json.loads(payment_response.json())
# TODO: exception handling
return (payment_response["confirmation"]["confirmation_url"],
payment_response.get('id'))
def get(self, type_id):
"""
Принимаем payment_id
:param request:
:param format:
:return:
"""
order_id = self.request.GET.get('order_id')
order = Orders.objects.get(id=order_id)
# status = int(order.status_order)
value = order.order_price
payment = Payment.create(
{
"amount": {
"value": value,
"currency": "RUB"
},
"confirmation": {
"type": "redirect",
"return_url": "http://192.168.1.131:8080/"
},
"capture": "false",
"description": "Заказ №1",
"metadata": {
"order_id": "37"
}
}, uuid.uuid4())
# get confirmation url
confirmation_url = payment.confirmation.confirmation_url
order.payment_id = payment.id
order.status_order = 2
order.save()
return HttpResponseRedirect(confirmation_url)
def charge_recurrent(self,
external_id: str,
amount: Decimal,
currency: str,
description: str) -> bool:
"""
Charge customer with saved payment information. Return false if not succeeded.
"""
payment_response = Payment.create({
"amount": {
"value": str(amount),
"currency": currency
},
"payment_method_id": external_id,
"description": description
})
payment_response = json.loads(payment_response.json())
status = payment_response.get('status')
if status == 'succeeded':
return True
if status == 'canceled' and payment_response['cancellation_details']['reason'] == 'permission_revoked':
return False
# Raise exception to retry task with backoff.
raise YandexPaymentError(f"Yandex payment error response {payment_response}")
Configuration.secret_key = 'test_N1nxSKIVxuNqTJIOC12laqvuVpFtH8_0Zsdby3F6T74'
payment = Payment.create({
"amount": {
"value": "500.00",
"currency": "RUB"
},
"confirmation": {
"type": "redirect",
"return_url": "https://www.merchant-website.com/return_url"
},
"capture": True,
"description": "Заказ №2",
'receipt': {
"customer": {
'phone': "79221379198"
},
"items": {
"description": "Сapybara",
"quantity": 5.000,
"amount": {
"value": "2500.50",
"currency": "RUB"
},
"vat_code": 2,
"payment_mode": "full_payment",
}
}
})
print(payment.confirmation.confirmation_url)
def post(self, request, *args, **kwargs):
Configuration.account_id = settings.YANDEX_ACCOUNT_ID
Configuration.secret_key = settings.YANDEX_SECRET_KEY
code = None
coupon = None
try:
code = self.request.data['code']
except KeyError:
pass
if self.request.data['game_id'] != kwargs.get('pk'):
return Response({
'game_id': 'Must be equal to game id from url!',
},
status=status.HTTP_400_BAD_REQUEST)
reserved_places_count = TemporaryReserve.objects.filter(
user=self.request.user.pk, game=kwargs.get('pk')).count()
if reserved_places_count == 0:
return Response(
{
'error':
'You have no reserved seats for this game or payment time exceeded 1 hour. Try again!',
},
status=status.HTTP_400_BAD_REQUEST)
game = Game.objects.get(pk=self.request.data['game_id'])
if code:
serializer = CouponCheckSerializer(data=self.request.data)
if serializer.is_valid():
coupon = Coupon.objects.get(
code=serializer.validated_data.get('code'))
if coupon.type == 'INDIVIDUAL':
if coupon.user != self.request.user:
return Response(
{
'error':
'Invalid user for this INDIVIDUAL coupon!',
},
status=status.HTTP_400_BAD_REQUEST)
summa = self.apply_individual_discount(
coupon, game, reserved_places_count)
else:
summa = self.apply_general_discount(
coupon, game, reserved_places_count)
else:
return Response(serializer.errors,
status=status.HTTP_400_BAD_REQUEST)
else:
summa = game.price * reserved_places_count
payment = Payment.create({
'amount': {
'value': str(summa),
'currency': 'RUB',
},
'confirmation': {
'type': 'embedded',
},
'capture': True,
'description': 'Description',
})
if coupon:
discount = round(coupon.discount, 2)
discount_units = coupon.units
else:
discount = 0
discount_units = ''
GamePayment.objects.create(
identifier=payment.id,
user=self.request.user,
game=game,
coupon=coupon,
summa=round(game.price * reserved_places_count, 2),
discount=discount,
discount_units=discount_units,
summa_with_discount=round(summa, 2),
currency='RUB',
places_count=reserved_places_count,
status='PENDING',
)
return Response(
{
'yandex_token': payment.confirmation.confirmation_token,
'payment_id': payment.id,
},
status=status.HTTP_200_OK)
import uuid
from yandex_checkout import Configuration, Payment
idemp_key = uuid.uuid4()
print(idemp_key)
Configuration.account_id = 'test_656330'
Configuration.secret_key = 'test_iGJ8jf2z8j8tWXgb8VKuwWZ3UD_69xrKiX7iqDHIcEc'
payment = Payment.create(
{
"amount": {
"value": "100.00",
"currency": "RUB"
},
"confirmation": {
"type": "redirect",
"return_url": "https://www.merchant-website.com/return_url"
},
"capture": True,
"description": "Заказ №1"
}, idemp_key)
def post(self, request, marathon_id):
user = self.request.user
if not models.Account.objects.filter(user=user).exists():
return HttpResponseRedirect('/')
log = models.Logging.objects.create(action="Создание платежа в Яндекс кассе. api/views.YandexPayment.post()")
account = user.account
result = {}
# lesson_num = request.POST.get('open_widget')
try:
marathon = models.Marathon.objects.get(pk=marathon_id)
# есть ли актуальный (не просроченный) платеж за урок
earlyer_pay = models.Payment.objects.filter(
account=account, marathon=marathon, date_approve__gte=timezone.now() - datetime.timedelta(days=62)
).exists()
if earlyer_pay:
raise Exception('Payment exists')
except:
result['error'] = 'Ошибка данных для формирования нового платежа'
return HttpResponseRedirect('/me')
if marathon.cost == 0:
try:
new_payment = models.Payment.objects.create(account=account,
marathon=marathon,
date_pay=timezone.now(),
date_approve=timezone.now(),
status="succeeded")
log.input_data = f"account {account.user.username}\nmarathon {marathon.pk}\ntime {timezone.now()}\n"
log.output_data = f"payment_pk {new_payment.pk},\nuuid {new_payment.pk}"
log.result = log.SUCCESS
log.save()
except Exception as exc:
log.result = log.FAIL
log.output_data = f"{exc}"
log.save()
return HttpResponseRedirect(f'/me?marathon={marathon.pk}')
try:
idempotence_key = uuid.uuid4()
Configuration.account_id = shopid
Configuration.secret_key = yandex_api_key
payment_params = {
"amount": {
"value": f"{marathon.cost}.00",
"currency": "RUB"
},
"confirmation": {
"type": "embedded"
},
"capture": True,
"description": f"Марафон {marathon.title[:75]}",
"receipt": {
"customer": {
"full_name": f"{account.user.get_full_name()}",
"phone": f"{account.phone}",
"email": f"{account.user.email}",
},
"items": [
{
"description": f"Марафон {marathon.title[:75]}",
"quantity": "1.00",
"amount": {
"value": f"{marathon.cost}.00",
"currency": "RUB"
},
"vat_code": "1",
# TODO 1-Без НДС 2-НДС по ставке 0% 3-НДС по ставке 10% 4-НДС чека по ставке 20% 5-НДС чека по расчетной ставке 10/110 6 НДС чека по расчетной ставке 20/120
"payment_mode": "full_prepayment",
"payment_subject": "intellectual_activity",
"save_payment_method": False,
# "receipt_phone":""
}
]
}}
payment = Payment.create(payment_params, idempotence_key)
payment_dict = {key: value.__dict__ if isinstance(value, BaseObject) else value for key, value in
payment.__dict__.items()}
log.input_data = f"{shopid}\n{yandex_api_key}\n{payment_params}\n{idempotence_key}"
except Exception as err:
log.result = log.FAIL
log.output_data = f"{err}"
log.save()
else:
new_payment = models.Payment.objects.create(uuid=idempotence_key,
amount=marathon.cost,
account=account,
marathon=marathon,
request=f"{shopid}\n{yandex_api_key}\n{payment_params}\n{idempotence_key}",
response=f"{payment_dict}",
yuid=payment.id,
status=payment.status,
confirmation_token=payment.confirmation.confirmation_token)
log.result = log.SUCCESS
log.output_data = f"{payment_dict}"
log.save()
return HttpResponseRedirect(f'/api/payment/widget/{idempotence_key}')
return HttpResponseRedirect(f'/me')
def cart(request):
try:
order = Order.objects.get(user=request.session.session_key,
status=Order.PENDING)
items = OrderItem.objects.filter(
order=order,
order__status=Order.PENDING,
)
categories = Category.objects.all()
total = sum([item.item.price * item.quantity for item in items])
content = {
'items': items,
'order': order,
'categories': categories,
'total': total
}
except mainapp.models.Order.DoesNotExist:
content = {}
if request.method == 'POST':
if request.POST.get('delivery-type', None) == 'card':
idempotence_key = str(uuid.uuid4())
payment = Payment.create(
{
"amount": {
"value": float(total),
"currency": "RUB"
},
"payment_method_data": {
"type": "bank_card",
"card": {
"number":
request.POST.get('card-number', None),
"expiry_year":
str(request.POST.get('expiry_year', None)),
"expiry_month":
str(request.POST.get('expiry_month', None)),
"cardholder":
request.POST.get('cardholder', None),
},
},
"confirmation": {
"type": "redirect",
"return_url": "https://www.vagonka40.ru/"
},
"description": "Заказ в vagonka40.ru"
}, idempotence_key)
# get confirmation url
payment_id = payment.id
idempotence_key = str(uuid.uuid4())
response = Payment.capture(
payment_id,
{"amount": {
"value": float(total),
"currency": "RUB"
}}, idempotence_key)
order.delivery_type = Order.CARD
else:
order.delivery_type = Order.PICKUP
order.email = request.POST['email']
order.name = request.POST['name']
order.phone = request.POST['phone']
order.status = Order.COMPLETED
order.save()
return HttpResponseRedirect(reverse('confirmation'))
return render(request, 'mainapp/cart.html', content)
def payment_process(*args, order_id):
Configuration.account_id = YANDEX_ID
Configuration.secret_key = YANDEX_KEY
# Configuration.account_id = TEST_YANDEX_ID
# Configuration.secret_key = TEST_YANDEX_KEY
order = Order.published.get(id=order_id)
value = float(order.get_total_cost() + order.deliver_cost)
json_yandex = {
"amount": {
"value": value,
"currency": "RUB"
},
"description": 'Номер заказа: {} от {}'.format(order.id, order.created.date()),
"metadata": {
"order_id": order.id
},
"capture": True,
"confirmation": {
"type": "redirect",
"return_url": "https://mrpit.online"
},
"receipt": {
"customer": {
"full_name": order.client.username,
"email": order.email,
"phone": order.phone
},
"items": [
]
},
}
items = order.items.all()
for item in items:
item = {
"description": item.flavour.product,
"quantity": item.quantity,
"amount": {
"value": item.price,
"currency": "RUB"
},
"vat_code": "2",
"payment_mode": "full_prepayment",
"payment_subject": "commodity"
}
json_yandex["receipt"]["items"].append(item)
delivery_item = {
"description": "Доставка",
"quantity": "1",
"amount": {
"value": order.deliver_cost,
"currency": "RUB"
},
"vat_code": "2",
"payment_mode": "full_prepayment",
"payment_subject": "commodity"
}
json_yandex["receipt"]["items"].append(delivery_item)
payment = Payment.create(json_yandex)
return redirect(payment.confirmation.confirmation_url)
