hossein-por-shop/backend/order/views.py

from django.shortcuts import render
from rest_framework.views import APIView, Response
from django.shortcuts import get_object_or_404
from product.models import ProductVariant
from rest_framework.permissions import IsAuthenticated
from .serializers import *
# from cart.models import 
from rest_framework import status
from .models import OrderItemModel, OrderModel, DiscountCode
from .permissons import CanDeleteCartItemPermissions, GetOrderPermission, SetAddressPermissions
from azbankgateways import bankfactories, models as bank_models
from azbankgateways.exceptions import AZBankGatewaysException
from drf_spectacular.utils import extend_schema, OpenApiParameter, OpenApiTypes, extend_schema_view
from utils.pagination import StructurePagination
from order.models import OrderModel
from django.urls import reverse
from account.models import UserAddressModel


# try:
#     pass
# except DiscountNotAvailableError:
#     pass


@extend_schema_view(
    post=extend_schema(tags=["cart discount code"]),
    delete=extend_schema(tags=["cart discount code"]),
)
class ApplyDiscountView(APIView):
    serializer_class = DiscountCodeSerializer
    permission_classes = [IsAuthenticated]
    def post(self, request):
        cart_order, created = OrderModel.objects.get_or_create(
            user=request.user,
            status='CART'
        )
        discount_code = get_object_or_404(DiscountCode, code=request.data.get('code'))
        
        if not discount_code.is_valid():
            return Response({'detail': discount_code.not_valid_reason()}, status=status.HTTP_400_BAD_REQUEST)
        cart_order.discount_code = discount_code
        cart_order.save()
        return Response({'detail': 'کد تخفیف با موفقیت اعمال شد'}, status=status.HTTP_200_OK)

    def delete(self, request):
        cart_order, created = OrderModel.objects.get_or_create(
            user=request.user,
            status='CART'
        )
        cart_order.discount_code =  None
        cart_order.save()
        return Response({'detail': 'کد تخفیف با موفقیت حذف شد'}, status=status.HTTP_204_NO_CONTENT)

class CartItemClear(APIView):
    permission_classes = [IsAuthenticated]
    serializer_class = OrderItemSerailzier
    @extend_schema(
        tags=["order cart"]
    )
    def delete(self, request):
        cart_order, created = OrderModel.objects.get_or_create(
            user=request.user,
            status='CART'
        )
        cart_order.items.all().delete()
        return Response({'detail': f'سبد خرید با موفقیت خالی شد'}, status=status.HTTP_204_NO_CONTENT)

@extend_schema_view(
    post=extend_schema(tags=["order cart"]),
    delete=extend_schema(tags=["order cart"]),
)
class CartItemViews(APIView):
    permission_classes = [IsAuthenticated]
    serializer_class = OrderItemSerailzier
    def post(self, request, pk):
        product_variant = get_object_or_404(ProductVariant, pk=pk)
        response = 'محصول با موفقیت به سبد خرید اضافه شد'
        quantity = request.data.get('quantity', 1)
        quantity = max(quantity, 0)
        if product_variant.in_stock < quantity:
            quantity = product_variant.in_stock
            response = 'تعداد درخواستی بیشتر از موجودی محصول میباشد'

        cart_order, created = OrderModel.objects.get_or_create(user=request.user, status='CART')
        order_item, created = OrderItemModel.objects.get_or_create(order=cart_order, product=product_variant, defaults={'quantity': quantity})

        if not created and order_item.quantity:  
            order_item.quantity = quantity
            order_item.save()
        if not order_item.quantity:
            order_item.delete()
        return Response({'detail': response, 'count': quantity}, status=status.HTTP_202_ACCEPTED)
    
    
    def delete(self, request, pk):
        order_item = get_object_or_404(OrderItemModel, pk=pk)
        permission = CanDeleteCartItemPermissions()

        if not permission.has_object_permission(request, self, order_item):
            return Response({"detail": permission.message}, status=status.HTTP_403_FORBIDDEN)

        order_item.delete()
        return Response(
            {"detail": "محصول با موفقیت از سبد خرید شما حذف شد"},
            status=status.HTTP_204_NO_CONTENT,
        )


class CartView(APIView):
    permission_classes = [IsAuthenticated]
    serializer_class = CartSerializer
    @extend_schema(
        tags=["order cart"]
    )
    def get(self, request):
        user = request.user
        cart_instance, created = OrderModel.objects.get_or_create(user=user, status='CART')
        cart_ser = self.serializer_class(instance=cart_instance, context={'request': request})
        return Response(cart_ser.data, status=status.HTTP_200_OK)


class OrderlistView(APIView):
    permission_classes = [IsAuthenticated]
    serializer_class = OrderListSerializer
    pagination_class = StructurePagination
    @extend_schema(
        parameters=[
            OpenApiParameter(
                name="limit",
                description="لیمیتش",
                required=False,
                type=OpenApiTypes.INT,
            ),
            OpenApiParameter(
                name="offset",
                description="افستش",
                required=False,
                type=OpenApiTypes.INT,
            ),
            OpenApiParameter(
                name="status",
                description=(
                    "['ADMIN_PENDING', 'PENDING', 'POSTED', 'RECEIVED', 'CANCELED', 'REFUNDED']"
                ),
                required=False,
                type=OpenApiTypes.STR,
            ),
            OpenApiParameter(
                name="sort",
                description=(
                    "Sort results by one of the following fields:\n"
                    "['created_at', '-created_at', 'final_price', '-final_price']"
                    "\nPrefix with `-` for descending order."
                ),
                required=False,
                type=OpenApiTypes.STR,
            ),
        ],
        tags=["order"]
    )
    def get(self, request):
        user = request.user
        orders = OrderModel.objects.filter(user=user).exclude(status="CART")
        status_filter = request.query_params.get("status", None)
        sort = request.query_params.get('sort', None)
        if status_filter in [ 'ADMIN_PENDING', 'PENDING', 'POSTED', 'RECEIVED', 'CANCELED', 'REFUNDED']:
            orders.filter(status=status_filter)
        if sort:
            if sort not in ['created_at', '-created_at', 'final_price', '-final_price']:
                return Response({'detail': 'پارامتر sort اشتباه است'}, status=status.HTTP_400_BAD_REQUEST)
            orders = orders.order_by(sort)
        paginator = self.pagination_class()
        paginated_orders = paginator.paginate_queryset(orders, request)
        orders_ser = self.serializer_class(instance=paginated_orders, many=True, context={'request': request})
        return paginator.get_paginated_response(orders_ser.data)



class OrderGetView(APIView):
    permission_classes = [IsAuthenticated, GetOrderPermission]
    serializer_class = OrderGetSerializer
    def get(self, request, pk):
        order_object = get_object_or_404(OrderModel, pk=pk)


        permission = GetOrderPermission()
        if not permission.has_object_permission(request, self, order_object):
            return Response({"detail": permission.message}, status=status.HTTP_403_FORBIDDEN)


        order_ser = self.serializer_class(order_object, context={'request': request})
        return Response(order_ser.data, status=status.HTTP_200_OK)



from rest_framework import serializers 

class BankTypeSerializer(serializers.Serializer):
    gateway_type = serializers.ChoiceField(choices=['ZIBAL', 'BMI', 'SEP', 'ZARINPAL', 'IDPAY', 'BAHAMTA', 'MELLAT', 'PAYV1'])


class PaymentView(APIView):
    permission_classes = [IsAuthenticated]
    serializer_class = BankTypeSerializer
    @extend_schema(
        description="choices=['BMI', 'SEP', 'ZARINPAL', 'IDPAY', 'ZIBAL', 'BAHAMTA', 'MELLAT', 'PAYV1']",
        tags=['order payment']
    )
    def post(self, request):
        print(request.data.get('gateway_type'))
        cart_order = get_object_or_404(OrderModel, user=request.user, status='CART')
        amount = 10000
        user_mobile_number = request.user.phone  

        factory = bankfactories.BankFactory()
        try:
            bank = (
                factory.create(
                    bank_models.BankType.ZIBAL
                )
            )  
            bank.set_request(request)
            bank.set_amount(amount)
            bank.set_client_callback_url('http://localhost:3000/transaction')
            bank.set_mobile_number(user_mobile_number)  

            bank_record = bank.ready()
            # cart_order.bank_records.add(bank_record)
            # cart_order.save()
            bank_record.order = cart_order
            bank_record.save()
            return Response(bank.get_gateway())
        except AZBankGatewaysException as e:
            print(e)
            return Response({'error': str(e)}, status=status.HTTP_400_BAD_REQUEST)

            



from django.views.decorators.csrf import csrf_exempt
from rest_framework.decorators import api_view
from rest_framework.response import Response
from azbankgateways import bankfactories, models as bank_models
from django.http import Http404, HttpResponse

@csrf_exempt
@api_view(['GET'])
def callback_view(request):
    tracking_code = request.GET.get('tc', None)
    if not tracking_code:
        logging.debug("این لینک معتبر نیست.")
        raise Http404

    try:
        bank_record = bank_models.Bank.objects.get(tracking_code=tracking_code)
    except bank_models.Bank.DoesNotExist:
        logging.debug("این لینک معتبر نیست.")
        raise Http404

    if bank_record.is_success:
        return HttpResponse("پرداخت با موفقیت انجام شد.")


    return HttpResponse(
        "پرداخت با شکست مواجه شده است. اگر پول کم شده است ظرف مدت ۴۸ ساعت پول به حساب شما بازخواهد گشت."
    )


from rest_framework import serializers
from azbankgateways.models import Bank
from azbankgateways.models.enum import PaymentStatus
from .permissons import PaymentCallBackPermissions

class BankCallbackSerializer(serializers.ModelSerializer):
    status_detail = serializers.SerializerMethodField()
    bank_type = serializers.SerializerMethodField()
    amount = serializers.SerializerMethodField()
    status = serializers.SerializerMethodField()
    class Meta:
        model = Bank
        fields = ['status', 'bank_type', 'tracking_code', 'amount', 'created_at', 'response_result', 'reference_number', 'status_detail']
    def get_status_detail(self, obj):
        return obj.get_status_display()
    def get_bank_type(self, obj):
        return obj.get_bank_type_display()
    def get_amount(self, obj):
        return f'{int(obj.amount):,.0f} تومان'
    def get_status(self, obj):
        if obj.status in {
            PaymentStatus.WAITING,
            PaymentStatus.REDIRECT_TO_BANK,
            PaymentStatus.RETURN_FROM_BANK,
        }:
            return "waiting"
        elif obj.status in {
            PaymentStatus.CANCEL_BY_USER,
            PaymentStatus.EXPIRE_GATEWAY_TOKEN,
            PaymentStatus.EXPIRE_VERIFY_PAYMENT,
            PaymentStatus.ERROR,
        }:
            return "canceled"
        elif obj.status == PaymentStatus.COMPLETE:
            return "succeeded"
        return "unknown"


class CallbackView(APIView):
    serializer_class = BankCallbackSerializer
    permission_classes = [IsAuthenticated]
    def get(self, request, tracking_code):
        if not tracking_code:
            return Response({'detail': 'تریسکد خالی است.'}, status=status.HTTP_400_BAD_REQUEST)

        try:
            bank_record = bank_models.Bank.objects.get(tracking_code=tracking_code)

            permission = PaymentCallBackPermissions()
            if not permission.has_object_permission(request, self, bank_record):
                return Response({"detail": permission.message}, status=status.HTTP_403_FORBIDDEN)
            
            bank_record_ser = self.serializer_class(instance=bank_record, context={'request': request})
        
        except bank_models.Bank.DoesNotExist:
            return Response({'detail': 'کد تریسکد معتبر نمیباشد.'}, status=status.HTTP_404_NOT_FOUND)

        if bank_record.is_success:
            return Response({"detail" : "پرداخت با موفقیت انجام شد.", "bank_result": bank_record_ser.data}, status=status.HTTP_200_OK)

        return Response(
            {"detail": "پرداخت با شکست مواجه شده است. اگر پول کم شده است ظرف مدت ۴۸ ساعت پول به حساب شما بازخواهد گشت.", "bank_result": bank_record_ser.data}, status=status.HTTP_200_OK
        )


class SetAddressSerilizer(serializers.Serializer):
    address_id = serializers.IntegerField()

class SetAddressForCartView(APIView):
    serializer_class = SetAddressSerilizer
    permission_classes = [IsAuthenticated, SetAddressPermissions]
    @extend_schema(
        tags=["order cart"]
    )
    def post(self, request):
        address_id = request.data.get('address_id', None)
        if not address_id:
            return Response({'detail': 'address_id را ارسال کنید'}, status=status.HTTP_400_BAD_REQUEST)
        address_object = get_object_or_404(UserAddressModel, pk=address_id)
        permission = SetAddressPermissions()
        if not permission.has_object_permission(request, self, address_object):
            return Response({"detail": permission.message}, status=status.HTTP_403_FORBIDDEN)
        
        cart_order, created = OrderModel.objects.get_or_create(
            user=request.user,
            status='CART'
        )
        cart_order.address = address_object
        cart_order.save()
        return Response({'detail': 'ادرس با موفقیت انتخاب شد'})