avto-cargo--wisdom--backend/core/apps/payment/views.py

import hashlib
import uuid

from payme.views import PaymeWebHookAPIView, PaymeTransactions
from payme import Payme

from django.conf import settings

from rest_framework.generics import GenericAPIView
from rest_framework.views import APIView
from rest_framework.response import Response
from rest_framework import status, permissions

from core.apps.orders.models import Order
from core.apps.payment.serializers import PaymentSerializer, VisaPaymentSerializer, PaymeSerializer
from core.services.payment import Atmos

payme = Payme(settings.PAYME_ID)

# def get_client_ip(request):
#     x_forwarded_for = request.META.get("HTTP_X_FORWARDED_FOR")
#     if x_forwarded_for:
#         ip = x_forwarded_for.split(",")[0]
#     else:
#         ip = request.META.get("REMOTE_ADDR")
#     return ip


class AtmosCallbackApiView(APIView):
    authentication_classes = []
    permission_classes = []

    def post(self, request):
        # client_ip = get_client_ip(request)
        # if client_ip not in settings.ALLOWED_ATMOS_IPS:
        #     return Response({"status": 0, "message": "IP ruxsat etilmagan"}, status=403)
        data = request.data
        if not data:
            return Response(
                {'success': 0, "message": "Request body required"},
                status=status.HTTP_200_OK
            )

        store_id = data.get("store_id")
        transaction_id = data.get("transaction_id")
        invoice = data.get("invoice")
        amount = data.get("amount")
        sign = data.get("sign")

        check_string = f"{store_id}{transaction_id}{invoice}{amount}{settings.API_KEY}"
        generated_sign = hashlib.md5(check_string.encode()).hexdigest()

        if generated_sign != sign:
            return Response(
                {"status": 0, "message": f"Инвойс с номером {invoice} отсутствует в системе"},
                status=status.HTTP_200_OK
            )

        try:
            order = Order.objects.get(order_number=invoice)
        except Order.DoesNotExist:
            return Response(
                {"status": 0, "message": f"Инвойс с номером {invoice} отсутствует в системе"},
                status=status.HTTP_200_OK
            )

        order.is_paid = True
        order.save()

        return Response(
            {"status": 1, "message": "Успешно"},
            status=status.HTTP_200_OK
        )


class PaymentGenerateLinkApiView(GenericAPIView):
    serializer_class = PaymentSerializer
    queryset = None
    permission_classes = [permissions.IsAuthenticated]

    def post(self, request):
        serializer = self.serializer_class(data=request.data)
        if not serializer.is_valid():
            return Response({'success': False, 'message': serializer.errors}, status=400)
        data = serializer.validated_data
        service = Atmos()
        res = service.create_transaction(data['price'], data['order_number'])
        link = service.generate_url(res['transaction_id'], 'https://wisdom.uz')
        return Response(
            {"success": True, "url": link},
            status=200
        )


class VisaMastercardPaymentApiView(GenericAPIView):
    queryset = None
    permission_classes = [permissions.IsAuthenticated]
    serializer_class = VisaPaymentSerializer

    def post(self, request):
        serializer = self.serializer_class(data=request.data)
        if not serializer.is_valid():
            return Response({'success': False, 'message': serializer.errors}, status=400)
        data = serializer.validated_data
        service = Atmos()
        res = service.global_payment(
            account=data.get('order_number'),
            request_id=str(uuid.uuid4()),
            amount=data.get('amount'),
        )
        return Response({'success': True, 'link': res})




class PaymeCallBackAPIView(PaymeWebHookAPIView):
    def handle_created_payment(self, params, result, *args, **kwargs):
        """
        Handle the successful payment. You can override this method
        """
        print(f"Transaction created for this params: {params} and cr_result: {result}")

    def handle_successfully_payment(self, params, result, *args, **kwargs):
        """
        Handle the successful payment. You can override this method
        """
        transaction = PaymeTransactions.get_by_transaction_id(
            transaction_id=params['id']
        )
        order = Order.objects.get(id=transaction.id)
        order.is_paid = True
        order.save()
        print(f"Transaction successfully performed for this params: {params} and performed_result: {result}")

    def handle_cancelled_payment(self, params, result, *args, **kwargs):
        """
        Handle the cancelled payment. You can override this method
        """
        transaction = PaymeTransactions.get_by_transaction_id(
            transaction_id=params['id']
        )
        if transaction.state == PaymeTransactions.CANCELED:
            order = Order.objects.get(id=transaction.id)
            order.is_paid = False
            order.save()
        print(f"Transaction cancelled for this params: {params} and cancelled_result: {result}")
    

class PayPaymeApiView(GenericAPIView):
    serializer_class = PaymeSerializer
    permission_classes = [permissions.IsAuthenticated]
    queryset = Order.objects.all()

    def post(self, request):
        serializer = self.serializer_class(data=request.data)
        if serializer.is_valid():
            order_id = serializer.validated_data.get('order_id')
            order = Order.objects.get(id=order_id)
            payment_link = payme.initializer.generate_pay_link(
                id=order_id,
                amount=order.total_price * 100,
                return_url="https://wisdom.uz",
            )
        
        return Response({'success': True, 'link': payment_link}, status=200)