413 lines
17 KiB
Python
413 lines
17 KiB
Python
from io import BytesIO
|
||
from typing import List
|
||
from uuid import uuid4
|
||
|
||
from fastapi import HTTPException
|
||
from number_to_string import get_string_by_number
|
||
from sqlalchemy import select
|
||
from sqlalchemy.orm import selectinload, joinedload
|
||
from starlette import status
|
||
from weasyprint import HTML, CSS
|
||
|
||
import backend.config
|
||
import constants
|
||
from constants import MONTHS, ENV
|
||
from external.billing import BillingClient, CreateBillingRequestValue, CreateBillRequestSchema, CreateBillRequestItems, \
|
||
BillStatusUpdateRequest, NotificationChannel, NotifyReceivedBillRequestSchema, DeleteBillRequestSchema, \
|
||
ProductBillingDocumentPdf, ServiceBillingDocumentPdf
|
||
from models import CardBillRequest, Card, CardProduct, CardService as CardServiceModel, CardGroup, \
|
||
GroupBillRequest
|
||
from schemas.auth import UserUnion
|
||
from schemas.billing import *
|
||
from services.base import BaseService
|
||
from services.card import CardsService
|
||
from utils.auth import verify_user_deal_editor
|
||
from utils.list_utils import to_locale_number
|
||
|
||
|
||
class BillingService(BaseService):
|
||
async def _process_card_update_details(
|
||
self,
|
||
request: BillStatusUpdateRequest,
|
||
):
|
||
bill_request = await self._get_card_bill_by_id(request.listener_transaction_id)
|
||
if not bill_request:
|
||
return
|
||
bill_request.pdf_url = request.info.pdf_url
|
||
bill_request.invoice_number = request.info.invoice_number
|
||
|
||
async def _process_group_update_details(
|
||
self,
|
||
request: BillStatusUpdateRequest,
|
||
):
|
||
prefix = "group-"
|
||
if not request.listener_transaction_id.startswith(prefix):
|
||
return
|
||
request_id = int(request.listener_transaction_id.removeprefix(prefix))
|
||
group_bill_request = await self._get_group_bill_by_id(request_id)
|
||
if not group_bill_request:
|
||
return
|
||
group_bill_request.pdf_url = request.info.pdf_url
|
||
group_bill_request.invoice_number = request.info.invoice_number
|
||
|
||
async def _process_update_details(
|
||
self,
|
||
request: BillStatusUpdateRequest
|
||
):
|
||
billing_client = BillingClient(backend.config.BILLING_API_KEY)
|
||
notify_received_request = NotifyReceivedBillRequestSchema(
|
||
listener_transaction_id=request.listener_transaction_id,
|
||
channel=NotificationChannel.PAYMENT_DETAILS,
|
||
received=True
|
||
)
|
||
response = await billing_client.notify_received(notify_received_request)
|
||
if not response.ok:
|
||
return
|
||
if type(request.listener_transaction_id) is int:
|
||
await self._process_card_update_details(request)
|
||
else:
|
||
await self._process_group_update_details(request)
|
||
await self.session.commit()
|
||
|
||
async def _process_card_update_verification(
|
||
self,
|
||
request: BillStatusUpdateRequest
|
||
):
|
||
card_bill_request = await self._get_card_bill_by_id(request.listener_transaction_id)
|
||
if not card_bill_request:
|
||
return
|
||
card_bill_request.paid = request.info.payed
|
||
|
||
async def _process_group_update_verification(
|
||
self,
|
||
request: BillStatusUpdateRequest
|
||
):
|
||
prefix = "group-"
|
||
if not request.listener_transaction_id.startswith(prefix):
|
||
return
|
||
group_id = int(request.listener_transaction_id.removeprefix(prefix))
|
||
group_bill_request = await self._get_group_bill_by_id(group_id)
|
||
if not group_bill_request:
|
||
return
|
||
group_bill_request.paid = request.info.payed
|
||
|
||
async def _process_update_verification(
|
||
self,
|
||
request: BillStatusUpdateRequest
|
||
):
|
||
billing_client = BillingClient(backend.config.BILLING_API_KEY)
|
||
notify_received_request = NotifyReceivedBillRequestSchema(
|
||
listener_transaction_id=request.listener_transaction_id,
|
||
channel=NotificationChannel.PAYMENT_VERIFICATION,
|
||
received=True
|
||
)
|
||
response = await billing_client.notify_received(notify_received_request)
|
||
if not response.ok:
|
||
return
|
||
if type(request.listener_transaction_id) is int:
|
||
await self._process_card_update_verification(request)
|
||
else:
|
||
await self._process_group_update_verification(request)
|
||
await self.session.commit()
|
||
|
||
async def process_update(
|
||
self,
|
||
request: BillStatusUpdateRequest
|
||
):
|
||
if request.channel == NotificationChannel.PAYMENT_DETAILS:
|
||
await self._process_update_details(request)
|
||
elif request.channel == NotificationChannel.PAYMENT_VERIFICATION:
|
||
await self._process_update_verification(request)
|
||
|
||
async def create_card_bill_request(self, card: Card) -> CardBillRequest:
|
||
card_bill_request = CardBillRequest(
|
||
card_id=card.id,
|
||
created_at=datetime.datetime.now()
|
||
)
|
||
self.session.add(card_bill_request)
|
||
await self.session.flush()
|
||
return card_bill_request
|
||
|
||
async def create_group_bill_request(self, group: CardGroup) -> GroupBillRequest:
|
||
group_bill_request = GroupBillRequest(
|
||
group_id=group.id,
|
||
created_at=datetime.datetime.now()
|
||
)
|
||
self.session.add(group_bill_request)
|
||
|
||
await self.session.flush()
|
||
return group_bill_request
|
||
|
||
@staticmethod
|
||
def _get_billing_values_from_services(services) -> List[
|
||
CreateBillingRequestValue
|
||
]:
|
||
billing_request_values: List[CreateBillingRequestValue] = []
|
||
|
||
for service in services:
|
||
# Omit services that have no price
|
||
if not service.price:
|
||
continue
|
||
billing_request_values.append(
|
||
CreateBillingRequestValue(
|
||
name=service.name,
|
||
price=service.price,
|
||
amount=service.quantity
|
||
)
|
||
)
|
||
return billing_request_values
|
||
|
||
async def create_card_billing(self, user, request: CreateCardBillRequest) -> CreateCardBillResponse:
|
||
try:
|
||
verify_user_deal_editor(user)
|
||
|
||
card_service = CardsService(self.session)
|
||
billing_client = BillingClient(backend.config.BILLING_API_KEY)
|
||
|
||
basic_card: Card = await card_service.get_by_id(user, request.card_id, return_raw=True)
|
||
if basic_card.group:
|
||
cards = await self._get_cards_by_group_id(basic_card.group.id)
|
||
else:
|
||
cards = [basic_card]
|
||
|
||
(services, products, is_size_needed) = await self._get_products_for_card(cards)
|
||
services: dict[str, ServiceBillingDocumentPdf]
|
||
products: dict[str, ProductBillingDocumentPdf]
|
||
is_size_needed: bool
|
||
billing_request_values: List[CreateBillingRequestValue] = self._get_billing_values_from_services(
|
||
services.values()
|
||
)
|
||
|
||
card = basic_card
|
||
transaction_prefix = "group-" if card.group else ""
|
||
inn: str = card.client.details.inn.strip()
|
||
|
||
one_request_size = 100
|
||
for i in range(0, len(billing_request_values), one_request_size):
|
||
values = billing_request_values[i:i + one_request_size]
|
||
|
||
if basic_card.group:
|
||
bill_request = await self.create_group_bill_request(basic_card.group)
|
||
else:
|
||
bill_request = await self.create_card_bill_request(basic_card)
|
||
|
||
listener_transaction_id = transaction_prefix + str(bill_request.id)
|
||
create_bill_request = CreateBillRequestSchema(
|
||
listener_transaction_id=listener_transaction_id,
|
||
payer_name=card.client.name,
|
||
payer_inn=inn,
|
||
payer_phone=card.client.details.phone_number,
|
||
items=CreateBillRequestItems(
|
||
values=values,
|
||
)
|
||
)
|
||
create_bill_response = await billing_client.create(create_bill_request)
|
||
|
||
if not create_bill_response.ok and 'Request already exists' in create_bill_response.message:
|
||
await self._cancel_one_bill(bill_request, listener_transaction_id)
|
||
create_bill_response = await billing_client.create(create_bill_request)
|
||
|
||
if not create_bill_response.ok:
|
||
raise Exception(create_bill_response.message or 'Неизвестная ошибка')
|
||
|
||
if card.group:
|
||
for card in card.group.cards:
|
||
card.is_locked = True
|
||
else:
|
||
card.is_locked = True
|
||
|
||
await self.session.commit()
|
||
return CreateCardBillResponse(ok=True, message='Заявка успешно создана!')
|
||
except Exception as e:
|
||
await self.session.rollback()
|
||
return CreateCardBillResponse(ok=False, message=str(e))
|
||
|
||
async def _get_card_bill_by_id(self, request_id: int) -> Optional[CardBillRequest]:
|
||
return await self.session.scalar(
|
||
select(CardBillRequest)
|
||
.where(CardBillRequest.id == request_id)
|
||
)
|
||
|
||
async def _get_card_bill_by_card_id(self, card_id: int) -> List[CardBillRequest]:
|
||
result = await self.session.scalars(
|
||
select(CardBillRequest)
|
||
.where(CardBillRequest.card_id == card_id)
|
||
)
|
||
return [*result.all()]
|
||
|
||
async def _get_group_bill_by_id(self, request_id: int) -> Optional[GroupBillRequest]:
|
||
return await self.session.scalar(
|
||
select(GroupBillRequest)
|
||
.where(GroupBillRequest.id == request_id)
|
||
)
|
||
|
||
async def _get_group_bill_by_group_id(self, group_id: int) -> List[GroupBillRequest]:
|
||
result = await self.session.scalars(
|
||
select(GroupBillRequest)
|
||
.where(GroupBillRequest.group_id == group_id)
|
||
)
|
||
return [*result.all()]
|
||
|
||
async def get_card_bill_by_id(self, card_id: int) -> GetCardBillById:
|
||
bill = await self._get_card_bill_by_id(card_id)
|
||
if not bill:
|
||
raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail='Card bill was not found')
|
||
return GetCardBillById(card_bill=CardBillRequestSchema.model_validate(bill))
|
||
|
||
async def _cancel_one_bill(self, bill: CardBillRequest | GroupBillRequest, listener_transaction_id: str) -> None:
|
||
billing_client = BillingClient(backend.config.BILLING_API_KEY)
|
||
response = await billing_client.delete(
|
||
DeleteBillRequestSchema(listener_transaction_id=listener_transaction_id)
|
||
)
|
||
|
||
if not response.ok:
|
||
raise Exception('Ошибка удаления счета со стороны Billing сервиса')
|
||
|
||
await self.session.delete(bill)
|
||
|
||
async def cancel_card_billing(self, user: UserUnion, request: CancelCardBillRequest) -> CancelCardBillResponse:
|
||
try:
|
||
verify_user_deal_editor(user)
|
||
|
||
card = await self._get_card_by_id(request.card_id)
|
||
if not card:
|
||
return CancelCardBillResponse(ok=False, message='Сделка не найдена')
|
||
|
||
if card.group:
|
||
bills = await self._get_group_bill_by_group_id(card.group.id)
|
||
else:
|
||
bills = await self._get_card_bill_by_card_id(request.card_id)
|
||
if not bills:
|
||
return CancelCardBillResponse(ok=False, message='Заявка не найдена')
|
||
|
||
for bill in bills:
|
||
if card.group:
|
||
listener_transaction_id = f"group-{bill.id}"
|
||
else:
|
||
listener_transaction_id = str(bill.id)
|
||
|
||
await self._cancel_one_bill(bill, listener_transaction_id)
|
||
|
||
await self.session.commit()
|
||
return CancelCardBillResponse(ok=True, message='Заявка успешно отозвана')
|
||
except Exception as e:
|
||
await self.session.rollback()
|
||
return CancelCardBillResponse(ok=False, message=str(e))
|
||
|
||
def _gen_key_for_service(self, service: ServiceBillingDocumentPdf) -> str:
|
||
return f"{service.name}-{service.price}"
|
||
|
||
def _gen_key_for_product(self, product: ProductBillingDocumentPdf) -> str:
|
||
article = product.article if product.article else uuid4()
|
||
return f"{article}-{product.size}-{product.price}"
|
||
|
||
async def _get_products_for_card(self, cards: list[Card]) -> tuple[dict, dict, bool]:
|
||
services: dict[str, ServiceBillingDocumentPdf] = {}
|
||
products: dict[str, ProductBillingDocumentPdf] = {}
|
||
is_size_needed: bool = False
|
||
|
||
for card in cards:
|
||
for product in card.products:
|
||
product_price = 0
|
||
for service in product.services:
|
||
service_data = ServiceBillingDocumentPdf(
|
||
name=f'[{product.product.name}] - {service.service.name}',
|
||
price=service.price,
|
||
quantity=product.quantity
|
||
)
|
||
key = self._gen_key_for_service(service_data)
|
||
if key in services:
|
||
services[key].quantity += product.quantity
|
||
else:
|
||
services[key] = service_data
|
||
product_price += service_data.price
|
||
is_size_needed = is_size_needed | bool(product.product.size)
|
||
product_data = ProductBillingDocumentPdf(
|
||
article=product.product.article,
|
||
size=product.product.size if product.product.size else "",
|
||
price=product_price,
|
||
quantity=product.quantity,
|
||
)
|
||
product_key = self._gen_key_for_product(product_data)
|
||
if product_key in products:
|
||
products[product_key].quantity += product_data.quantity
|
||
else:
|
||
products[product_key] = product_data
|
||
for service in card.services:
|
||
service_data = ServiceBillingDocumentPdf(
|
||
name=service.service.name,
|
||
price=service.price,
|
||
quantity=service.quantity
|
||
)
|
||
key = self._gen_key_for_service(service_data)
|
||
if key in services:
|
||
services[key].quantity += service_data.quantity
|
||
else:
|
||
services[key] = service_data
|
||
|
||
return services, products, is_size_needed
|
||
|
||
async def _get_card_by_id(self, card_id: int) -> Optional[Card]:
|
||
card: Card | None = await self.session.scalar(
|
||
select(Card)
|
||
.where(Card.id == card_id)
|
||
.options(
|
||
selectinload(Card.products).selectinload(CardProduct.services),
|
||
selectinload(Card.services).selectinload(CardServiceModel.service),
|
||
joinedload(Card.shipping_warehouse),
|
||
joinedload(Card.client),
|
||
selectinload(Card.group).selectinload(CardGroup.cards),
|
||
)
|
||
)
|
||
return card
|
||
|
||
async def _get_cards_by_group_id(self, group_id: int) -> List[Card]:
|
||
group: CardGroup | None = await self.session.scalar(
|
||
select(CardGroup)
|
||
.where(CardGroup.id == group_id)
|
||
.options(
|
||
selectinload(CardGroup.cards).selectinload(Card.products).selectinload(CardProduct.services),
|
||
selectinload(CardGroup.cards).selectinload(Card.services).selectinload(CardServiceModel.service),
|
||
selectinload(CardGroup.cards).joinedload(Card.shipping_warehouse),
|
||
selectinload(CardGroup.cards).joinedload(Card.client),
|
||
selectinload(CardGroup.cards).selectinload(Card.group).selectinload(CardGroup.cards),
|
||
)
|
||
)
|
||
return group.cards if group else []
|
||
|
||
async def _create_billing_document_html(self, card_id: int):
|
||
card = await self._get_card_by_id(card_id)
|
||
if not card:
|
||
return ""
|
||
|
||
if card.group:
|
||
cards = await self._get_cards_by_group_id(card.group.id)
|
||
else:
|
||
cards = [card]
|
||
|
||
(services, products, is_size_needed) = await self._get_products_for_card(cards)
|
||
|
||
price = sum((service.price * service.quantity for service in services.values()))
|
||
price_words = get_string_by_number(price)[0:-10]
|
||
price = to_locale_number(price)
|
||
template = ENV.get_template("bill-of-payment.html")
|
||
|
||
now = datetime.datetime.now()
|
||
curr_date = f"{now.day} {MONTHS[now.month - 1]} {now.year} г."
|
||
return template.render({
|
||
"products": products,
|
||
"services": services,
|
||
"is_size_needed": is_size_needed,
|
||
"deal_price": price,
|
||
"deal_price_words": price_words,
|
||
"deal": card,
|
||
"curr_date": curr_date
|
||
})
|
||
|
||
async def create_billing_document_pdf(self, card_id) -> BytesIO:
|
||
doc = await self._create_billing_document_html(card_id)
|
||
pdf_file = BytesIO()
|
||
HTML(string=doc).write_pdf(pdf_file, stylesheets=[CSS(constants.APP_PATH + '/static/css/bill-of-payment.css')])
|
||
|
||
return pdf_file
|