from calendar import month
from pickle import NONE
from wsgiref.validate import PartialIteratorWrapper
from django.shortcuts import render
from django.http import HttpResponse
from rest_framework.views import APIView
from rest_framework.response import Response
from rest_framework import status
from rest_framework.parsers import MultiPartParser
from rest_framework import status,generics,permissions
from rest_framework.response import Response
from uritemplate import partial
from magazine.fcm import send_push_notification
from magazineapp.models import*
from .serializers import*
# from loguru import logger
import logging
logger = logging.getLogger(__name__)
from django.core import mail
from rest_framework.permissions import AllowAny,IsAuthenticated
from rest_framework import generics, status, permissions
# from rest_framework.pagination import PageNumberPagination
# from .paginations import GpiPagination
from django.db.models import Q
import django_filters.rest_framework
from rest_framework.filters import OrderingFilter,SearchFilter
from django.http import Http404
from .magazine_message import*
from rest_framework import filters
from django.db.models import F
import string
import random
from base.threads import*


#admin
def validateBackground(request, pk):
    mag = MagazineInfo.objects.get(pk=pk)
    mag.is_promoted = True
    mag.save()
    if mag.is_promoted is True:
        mag.background_color = '#5EFFFF'
        mag.save()
    return HttpResponse({'Background colour changed'}) 

#pagination
# class MagazineCategoryAPIView(generics.ListAPIView):
#     serializer_class = MagazineCategorySerializer
#     pagination_class = GpiPagination
#     def get_queryset(self):
#         return MagazineCategory.objects.all()

#magazine category
class MagazineCategoryAPIView(generics.ListAPIView):
    serializer_class = MagazineCategorySerializer
    # pagination_class = GpiPagination
    # permission_classes = (permissions.IsAuthenticated,)
    def get(self, request,id=None):
        try:   
            users=MagazineCategory.objects.all()
            serializer = self.serializer_class(users,many=True)
            context = {'status': 1,'message': magazinecategory_message['message'],'data':serializer.data}
            return Response(context, status=status.HTTP_200_OK)
        except Exception as e:
            logger.error('MagazineCategoryAPIView:error => ' + str(e))
            context = {'status': 0, 'message': Exp_MESSAGE['message']}
            return Response(context, status=status.HTTP_400_BAD_REQUEST)

#system category
class SystemCategoryAPIView(generics.GenericAPIView):
    serializer_class = SystemCategorySerializer
    # permission_classes = (permissions.IsAuthenticated,)
    def get(self, request,id=None):
        try:   
            users=SystemCategory.objects.all()
            serializer = self.serializer_class(users,many=True)
            context = {'status': 1,'message': systemcategory_message['message'],'data':serializer.data}
            return Response(context, status=status.HTTP_200_OK)
        except Exception as e:
            logger.error('SystemCategoryAPIView:error => ' + str(e))
            context = {'status': 0, 'message': Exp_MESSAGE['message']}
            return Response(context, status=status.HTTP_400_BAD_REQUEST)

#promotional magazine
class PromotionalMagazineAPIView(generics.GenericAPIView):
    serializer_class = MagazineInfoSerializer
    # permission_classes = (permissions.IsAuthenticated,)
    def get(self, request,id=None):
        try:   
            # users=MagazineInfo.objects.all()
            users=MagazineInfo.objects.filter(is_aproved=True,is_active=True).all()
            serializer = self.serializer_class(users,many=True)
            context = {'status': 1,'message': PromotionalMagazine_message['message'],'data':serializer.data}
            return Response(context, status=status.HTTP_200_OK)
        except Exception as e:
            logger.error('PromotionalMagazineAPIView:error => ' + str(e))
            context = {'status': 0, 'message': Exp_MESSAGE['message']}
            return Response(context, status=status.HTTP_400_BAD_REQUEST)

# magazine by system category
class MagazinebySystemcategoryAPIView(generics.GenericAPIView):
    permission_classes = (permissions.AllowAny,)
 
    def get(self, request):
        try:
            user_id = self.request.query_params.get('user_id', None)
            system_category_id = self.request.query_params.get('system_category_id', None)
            magazine_category_id = self.request.query_params.get('magazine_category_id', None)

            if system_category_id and magazine_category_id:
                self.serializer_class = SystemAndMagazineDetailsSerializer
                mangine = MagazineInfo.objects.filter(system_category=system_category_id,magazine_category=magazine_category_id).values('system_category').distinct()
                serializer = self.serializer_class(mangine, many=True,context={'system_category_id':system_category_id,'magazine_category_id':magazine_category_id,'user_id':user_id })
                context = {'status': 1,'message': magazinebysystem_message['message'],'data':serializer.data}
                return Response(context, status=status.HTTP_201_CREATED)
                
            elif system_category_id:
                self.serializer_class = SystemCategorySerializer
                sys_category = SystemCategory.objects.filter(id=system_category_id).all()
                serializer = self.serializer_class(sys_category, many=True,context={'user_id':user_id})
                context = {'status': 1,'message': magazinebysystem_message['message'],'data':serializer.data}
                return Response(context, status=status.HTTP_201_CREATED)

            elif magazine_category_id:
                self.serializer_class = SystemppCategorySerializer
                sys_category = MagazineCategory.objects.filter(id=magazine_category_id).all()
                serializer = self.serializer_class(sys_category, many=True,context={'user_id':user_id})
                context = {'status': 1,'message': magazinebysystem_message['message'],'data':serializer.data}
                return Response(context, status=status.HTTP_201_CREATED)
                
            else:

                self.serializer_class = SystemCategorySerializer
                mangine = SystemCategory.objects.filter().all()

                # print(user_id,'=====userid 33  ======>>>>>>>>>>>>>>>>')
                # breakpoint()
                serializer = self.serializer_class(mangine, many=True,context={"user_id":user_id})
                context = {'status': 1,'message': magazinebysystem_message['message'],'data':serializer.data}
                return Response(context, status=status.HTTP_201_CREATED)

        except Exception as e:
            logger.error('MagazinebySystemcategoryAPIView:error => ' + str(e))
            context = {'status': 0, 'message': Exp_MESSAGE['message'],'error':str(e)}
            return Response(context, status=status.HTTP_400_BAD_REQUEST)

# filter data
# class Search123APIView(generics.ListAPIView):
#     filter_backends = [django_filters.rest_framework.DjangoFilterBackend, OrderingFilter]
#     filterset_fields = ['system_category','magazine_category','id']
#     serializer_class = MagazinebySystemSerializer
   
#     def get_queryset(self):
#         try:
#             return MagazineInfo.objects.all()
#         except Exception as e:
#             context = {'status': 0, 'message': Exp_MESSAGE['message'],'error':str(e)}
#             return Response(context, status=status.HTTP_400_BAD_REQUEST)
    

# #magazine detail
# class MagazineDetailAPIView(generics.GenericAPIView):
#     serializer_class = magazineSerializer
#     # permission_classes = (permissions.IsAuthenticated,)

#     def get(self,request,format=None):
#         try:
#             user_id = self.request.query_params.get('user_id',None)
#             magazine_id = self.request.query_params.get('magazine_id', None)
#             if not magazine_id:
#                 context = {'status': 0,'message':'please enter magazine id.'}
#                 return Response(context, status=status.HTTP_200_OK)
#             Magazineobj = MagazineInfo.objects.filter(id=magazine_id,is_aproved=True,is_active=True).last()

#             if Magazineobj and user_id:
#                 try:
#                     userbookobj = MagazineBookmark.objects.filter(magazines=magazine_id,users=user_id).last()
#                     if userbookobj:
#                         MagazineInfo.objects.filter(id=magazine_id).update(is_bookmark=True)
#                     else:
#                         MagazineInfo.objects.filter(id=magazine_id).update(is_bookmark=False)
#                 except MagazineBookmark.DoesNotExist:
#                     pass
                
#                 try:
#                     userfauvariteobj = MagazineFavorite.objects.filter(magazines=magazine_id,users=user_id).last()
#                     if userfauvariteobj:
#                         MagazineInfo.objects.filter(id=magazine_id).update(is_favorite=True)
#                     else:
#                         MagazineInfo.objects.filter(id=magazine_id).update(is_favorite=False)
#                 except MagazineFavorite.DoesNotExist:
#                     pass

#                 try:
#                     userpurchaseobj = MagazinePurchaseInfo.objects.filter(magazineInfos=magazine_id,users=user_id,is_buyed=True).first()
#                     if userpurchaseobj:
#                         MagazineInfo.objects.filter(id=magazine_id).update(is_purchase=True)
#                     else:
#                         MagazineInfo.objects.filter(id=magazine_id).update(is_purchase=False)
#                 except MagazinePurchaseInfo.DoesNotExist:
#                     pass

#                 try:
#                     readstatusobj = MagazineReadStatus.objects.filter(magazine=magazine_id,user=user_id).first()
#                     if readstatusobj:
#                         MagazineInfo.objects.filter(id=magazine_id).update(is_read_status=True)
#                     else:
#                         MagazineInfo.objects.filter(id=magazine_id).update(is_read_status=False)
#                 except MagazineReadStatus.DoesNotExist:
#                     pass

#                 # try:
#                 #     rentedobj = MagazinePurchaseInfo.objects.filter(magazineInfos=magazine_id,users=user_id,is_rented=True,subscription_user_status=True).first()
#                 #     print('>>>>>>>>>>>>>>')
#                 #     if rentedobj:
#                 #         print(rentedobj, 'rentedobj')
#                 #         # breakpoint()
#                 #         current_date = datetime.datetime.now() 
#                 #         if rentedobj.rent_date <=current_date <= rentedobj.rent_expiry_date:
#                 #             # MagazineInfo.objects.filter(id=magazine_id).update(is_rented=True)
#                 #             pass
#                 #         else:
#                 #             MagazinePurchaseInfo.objects.filter(id=magazine_id, users=user_id).update(subscription_user_status=False)
#                 # except MagazinePurchaseInfo.DoesNotExist:
#                 #     pass
                
#                 magazinedata=MagazineInfo.objects.get(id=magazine_id)
#                 serializers = magazineSerializer(magazinedata,context = {"user":user_id},many=False)
#                 context = {'status': 1,'message':magazinedetail_message['message'],"data":serializers.data}
#                 return Response(context, status=status.HTTP_200_OK)

#             if Magazineobj:
#                 serializers = AlldataSerializer(Magazineobj,many=False)
#                 context = {'status': 1,'message': magazinedetail_message['message'],'data':serializers.data}
#                 return Response(context, status=status.HTTP_200_OK)

#             # if not userobj:
#             #     context = {'status': 0,'message':'Record is not available.'}
#             #     return Response(context, status=status.HTTP_200_OK)
#             if not Magazineobj:
#                 context = {'status': 0,'message':'Record is not available.'}
#                 return Response(context, status=status.HTTP_200_OK)

#         except Exception as e:
#             logger.error('MagazineDetailAPIView:error => ' + str(e))
#             context = {'status': 0, 'message': Exp_MESSAGE['message']}
#             return Response(context, status=status.HTTP_400_BAD_REQUEST)


# server magazine detail
class MagazineDetailAPIView(generics.GenericAPIView):
    serializer_class = magazineSerializer
    # permission_classes = (permissions.IsAuthenticated,)

    def get(self,request,format=None):
        try:
            user_id = self.request.query_params.get('user_id',None)
            magazine_id = self.request.query_params.get('magazine_id', None)
            if not magazine_id:
                context = {'status': 0,'message':'please enter magazine id.'}
                return Response(context, status=status.HTTP_200_OK)
            Magazineobj = MagazineInfo.objects.filter(id=magazine_id,is_aproved=True,is_active=True).last()
            # userobj = None
            # if user_id:
            #     userobj = User.objects.filter(id=user_id).last()

            ##########################
            # magazineobj = MagazineInfo.objects.filter(id=magazine_id,magazine_type__iexact='standard').last()
            # issuesobj = MagazineInfo.objects.filter(id=magazine_id,magazine_type__iexact='issues').last()
            ##########################

            if Magazineobj and user_id:

                userbookobj = MagazineBookmark.objects.filter(magazines=magazine_id,users=user_id).last()
                userfauvariteobj = MagazineFavorite.objects.filter(magazines=magazine_id,users=user_id).last()
                userpurchaseobj = MagazinePurchaseInfo.objects.filter(magazineInfos=magazine_id,users=user_id,is_buyed=True).first()
                readstatusobj = MagazineReadStatus.objects.filter(magazine=magazine_id,user=user_id).first()
                rentedobj = MagazinePurchaseInfo.objects.filter(magazineInfos=magazine_id,users=user_id,is_rented=True,subscription_user_status=True).first()
                # subscriptionobj = MagazinePurchaseInfo.objects.filter(magazineInfos=magazine_id,users=user_id,is_subscription=True).first()
                # ##########################
                # current_date = datetime.datetime.now() 
                # duration = rentedobj.rent_date <=current_date <= rentedobj.rent_expiry_date
                # ############################
                if userbookobj:
                    MagazineInfo.objects.filter(id=magazine_id).update(is_bookmark=True)
                else:
                    MagazineInfo.objects.filter(id=magazine_id).update(is_bookmark=False)

                if userfauvariteobj:
                    MagazineInfo.objects.filter(id=magazine_id).update(is_favorite=True)
                else:
                    MagazineInfo.objects.filter(id=magazine_id).update(is_favorite=False)

                if userpurchaseobj:
                    MagazineInfo.objects.filter(id=magazine_id).update(is_purchase=True)
                else:
                    MagazineInfo.objects.filter(id=magazine_id).update(is_purchase=False)

                if readstatusobj:
                    MagazineInfo.objects.filter(id=magazine_id).update(is_read_status=True)
                else:
                    MagazineInfo.objects.filter(id=magazine_id).update(is_read_status=False)

                if rentedobj:
                    MagazineInfo.objects.filter(id=magazine_id).update(is_rented=True)
                else:
                    MagazineInfo.objects.filter(id=magazine_id).update(is_rented=False)

                magazinedata=MagazineInfo.objects.get(id=magazine_id)
                serializers = magazineSerializer(magazinedata,context = {"user":user_id},many=False)
                context = {'status': 1,'message':magazinedetail_message['message'],"data":serializers.data}
                return Response(context, status=status.HTTP_200_OK)

            if Magazineobj:
                serializers = AlldataSerializer(Magazineobj,many=False)
                context = {'status': 1,'message': magazinedetail_message['message'],'data':serializers.data}
                return Response(context, status=status.HTTP_200_OK)

            # if not userobj:
            #     context = {'status': 0,'message':'Record is not available.'}
            #     return Response(context, status=status.HTTP_200_OK)
            if not Magazineobj:
                context = {'status': 0,'message':'Record is not available.'}
                return Response(context, status=status.HTTP_200_OK)

        except Exception as e:
            logger.error('MagazineDetailAPIView:error => ' + str(e))
            context = {'status': 0, 'message': Exp_MESSAGE['message']}
            return Response(context, status=status.HTTP_400_BAD_REQUEST)

#magazine bookmark
class MagazineBookmarkAPIView(generics.GenericAPIView):
    serializer_class = MagazineBookmarkSerializer
    # permission_classes = (permissions.IsAuthenticated,)
 
    def post(self, request,id=None):
        try:
            is_bookmark =request.data.get('is_bookmark', None)
            data=request.data
            data['magazines']=data['magazines_id']
            data['users']=data['users_id']
            data['page_number']=data['page_number']
          
            usersdata=User.objects.filter(id=data['users']).last()
       
            if not usersdata:
                context = {'status': 0,'message':'User record is not available.'}
                return Response(context, status=status.HTTP_200_OK)
                
            if is_bookmark==True:
                # bookmarkobj=MagazineBookmark.objects.filter(users=usersdata.id,magazines=data['magazines']).last()
                # if bookmarkobj is None:
                serializer=MagazineBookmarkSerializer(data=data)
                if serializer.is_valid():
                    serializer.save()                    
                    context = {'status': 1,'message': bookmark_enter_message['message'],'data':serializer.data}
                    return Response(context, status=status.HTTP_200_OK)
                else:
                    context = {'status': 0,'message':'Record is not available'}
                    return Response(context, status=status.HTTP_200_OK)
                # else:
                #     serializer=MagazineBookmarkSerializer(bookmarkobj)
                #     context = {'status': 1,'message': 'Record bookmark Successfully.','data':serializer.data}
                #     return Response(context, status=status.HTTP_200_OK)

            elif is_bookmark==False:
                bookmarkobj=MagazineBookmark.objects.filter(users=usersdata.id,magazines=data['magazines']).last()
                if bookmarkobj:
                    MagazineBookmark.objects.filter(id=bookmarkobj.id).delete()
                    context = {'status': 1,'message':bookmark_delete_message['message']}
                    return Response(context, status=status.HTTP_200_OK)
                else:
                    context = {'status': 0,'message':'Record is not available'}
                    return Response(context, status=status.HTTP_200_OK)
                    
            else:

                context = {'status': 0,'message':'Please enter correct bookmark type'}
                return Response(context, status=status.HTTP_200_OK)
        
        except Exception as e:
            logger.error('MagazineBookmarkAPIView:error => ' + str(e))
            context = {'status': 0, 'message': Exp_MESSAGE['message']}
            return Response(context, status=status.HTTP_400_BAD_REQUEST)

# Show get magazine bookmark list
class BookmarkListAPIView(generics.GenericAPIView):
    serializer_class = BookmarkListSerializer
    # permission_classes = (permissions.IsAuthenticated,)
 
    def get(self, request,id=None):
        try:
            orderobj = MagazineBookmark.objects.all()
            serializers = self.serializer_class(orderobj,many=True)
            context = {'status': 1,'message':Bookmark_list_message['message'],'data':serializers.data}
            return Response(context, status=status.HTTP_200_OK)

        except Exception as e:
            logger.error('BookmarkListAPIView:error => ' + str(e))
            context = {'status': 0, 'message': Exp_MESSAGE['message']}
            return Response(context, status=status.HTTP_400_BAD_REQUEST)


#magazine Favorite
class MagazineFavoriteAPIView(generics.GenericAPIView):
    serializer_class = MagazineFavoriteSerializer
    # permission_classes = (permissions.IsAuthenticated,)
 
    def post(self, request,id=None):
        try:
            is_favorite =request.data.get('is_favorite', None)
            # favorite_type=is_favorite.lower()
            data=request.data
            data['magazines']=data['magazines_id']
            data['users']=data['users_id']
            data['page_number']=data['page_number']
            usersdata=User.objects.filter(id=data['users']).last()
            if not usersdata:
                context = {'status': 0,'message':'User record is not available.'}
                return Response(context, status=status.HTTP_200_OK)
            if is_favorite==True:
                favoriteobj=MagazineFavorite.objects.filter(users=usersdata.id,magazines = data['magazines']).last()
                if favoriteobj is None:
                    serializer=MagazineFavoriteSerializer(data=data)
                    if serializer.is_valid():
                        serializer.save()                    
                        context = {'status': 1,'message': Favorite_enter_message['message'],'data':serializer.data}
                        return Response(context, status=status.HTTP_200_OK)
                    else:
                        context = {'status': 0,'message':'Record is not available'}
                        return Response(context, status=status.HTTP_200_OK)
                else:
                    serializer=MagazineFavoriteSerializer(favoriteobj)
                    context = {'status': 1,'message': 'Favourite record already create successfully.','data':serializer.data}
                    return Response(context, status=status.HTTP_200_OK)
                    
            elif is_favorite==False:
                usersdata=User.objects.filter(id=data['users']).last()
                favoriteobj=MagazineFavorite.objects.filter(users=usersdata.id,magazines = data['magazines']).last()
                if favoriteobj:
                    MagazineFavorite.objects.filter(id=favoriteobj.id).delete()
                    context = {'status': 1,'message':Favorite_delete_message['message']}
                    return Response(context, status=status.HTTP_200_OK)
                else:
                    context = {'status': 0,'message':'Record is not available'}
                    return Response(context, status=status.HTTP_200_OK)
            else:
                context = {'status': 0,'message':'Please enter correct favorite type'}
                return Response(context, status=status.HTTP_200_OK)

        except Exception as e:
            logger.error('MagazineFavoriteAPIView:error => ' + str(e))
            context = {'status': 0, 'message': Exp_MESSAGE['message']}
            return Response(context, status=status.HTTP_400_BAD_REQUEST)

#magazine Purchase
class MagazinePurchaseAPIView(generics.GenericAPIView):
    serializer_class = PurchaseInfoSerializer
    # permission_classes = (permissions.IsAuthenticated,)
 
    def post(self, request,id=None):
        try:
            is_purchase =request.data.get('is_purchase', None)
            data=request.data
            data['magazineInfos']=data['magazine_id']
            data['users']=data['user_id']
            data['page_number']=data['page_number']
            usersdata=User.objects.filter(id=data['users'])
            if not usersdata:
                context = {'status': 0,'message':'User record is not available.'}
                return Response(context, status=status.HTTP_200_OK)
            pagesdata=MagazineInfo.objects.filter(id=data['magazineInfos'],users= data['users']).last()
            if pagesdata:
                if is_purchase==True:
                    purchaselistobj = MagazinePurchaseInfo.objects.filter(magazineInfos=data['magazineInfos'],users=data['users']).last()
                    if purchaselistobj is None:                  
                        serializer=PurchaseInfoSerializer(data=data)
                        if serializer.is_valid():
                            serializer.save()                    
                            context = {'status': 1,'message': Purchase_enter_message['message'],'data':serializer.data}
                            return Response(context, status=status.HTTP_200_OK)
                        else:
                            context = {'status': 0,'message':'Record is not available'}
                            return Response(context, status=status.HTTP_200_OK)
                    else:
                        serializer=PurchaseInfoSerializer(purchaselistobj)
                        context = {'status': 1,'message': 'Purchase record already create  successfully.','data':serializer.data}
                        return Response(context, status=status.HTTP_200_OK)

                elif is_purchase==False:
                    usersdata=User.objects.filter(id=data['users']).last()
                    purchaseobj=MagazinePurchaseInfo.objects.filter(users=usersdata.id).last()
                    if purchaseobj:
                        MagazinePurchaseInfo.objects.filter(id=purchaseobj.id).delete()
                        context = {'status': 1,'message':Purchase_delete_message['message']}
                        return Response(context, status=status.HTTP_200_OK)
                    else:
                        context = {'status': 0,'message':'Record is not available'}
                        return Response(context, status=status.HTTP_200_OK)
                else:
                    context = {'status': 0,'message':'Please enter correct purchase type'}
                    return Response(context, status=status.HTTP_200_OK)
            else:
                context = {'status': 0,'message':'User and magazine id are not available.'}
                return Response(context, status=status.HTTP_200_OK)
        except Exception as e:
            logger.error('MagazinePurchaseAPIView:error => ' + str(e))
            context = {'status': 0, 'message': Exp_MESSAGE['message']}
            return Response(context, status=status.HTTP_400_BAD_REQUEST)


# Magazine Liberary Api
class MyLibraryAPIView(generics.ListAPIView):
    serializer_class = magazineliberarySerializer
    def post(self, request,id=None):
        try:
            request.data['users']=request.data['user_id']
            request.data['magazineInfos']=request.data['magazine_id']
            serializer = PurchaseInfoSerializer(data=request.data)
            if serializer.is_valid():
                serializer.save()
                context = {'status': 1,'message':mylibrary_message['message'],'data':serializer.data}
                return Response(context, status=status.HTTP_200_OK)
            else:
                context = {'status': 0,'message':mylibrary_errormessage['message']}
                return Response(context, status=status.HTTP_200_OK)
        except Exception as e:
            logger.error('MyLibraryAPIView:error => ' + str(e))
            context = {'status': 0, 'message': Exp_MESSAGE['message']}
            return Response(context, status=status.HTTP_400_BAD_REQUEST)


    def get(self, request,id=None):
        try:
            userid = self.request.query_params.get('user_id', None)
            filter_type = self.request.query_params.get('filter_type', None)

            if not userid:
                context = {'status': 0,'message':'Please enter correct user id.'}
                return Response(context, status=status.HTTP_200_OK)
            magazineobj=MagazineInfo.objects.filter(users=userid).last()
            purchaseobj=MagazinePurchaseInfo.objects.filter(users=userid)

            # if not purchaseobj:
            #     context = {'status': 0,'message':'User record is not available.'}
            #     return Response(context, status=status.HTTP_200_OK)

            if filter_type=="Bookmark":
                # bookmarkobj=MagazineInfo.objects.filter(id=magazineobj.id).all().order_by('-create_on')
                bookmark_id_li = MagazineBookmark.objects.filter(users = userid).values_list('magazines', flat = True)
                bookmarkobj=MagazineInfo.objects.filter(id__in = bookmark_id_li,is_aproved=True,is_active=True).all()
                serializer = magazineliberarySerializer(bookmarkobj,many=True)
                dict={"Bookmark":serializer.data}
                context = {'status': 1,'message':Bookmark_message['message'],'data':dict}  

            elif filter_type=="Purchase":
                purchaseobj=MagazinePurchaseInfo.objects.filter(users=userid,is_buyed=True)
                serializer = MagazinePurchaseInfoSerializer(purchaseobj,many=True)
                dict={"Purchase":serializer.data}
                context = {'status': 1,'message':Purchase_enter_message['message'],'data':dict}   

            elif filter_type=="Favourite":
                favorite_id_li = MagazineFavorite.objects.filter(users = userid).values_list('magazines', flat = True)
                favouriteobj=MagazineInfo.objects.filter(id__in = favorite_id_li,is_aproved=True,is_active=True).all()
                serializer = magazineliberarySerializer(favouriteobj,many=True)
                dict={"Favourite":serializer.data}
                context = {'status': 1,'message':Favourite_message['message'],'data':dict}
               
            else:
            #     bookmarkdata = []
            #     favouritedata = []
            #     purchasedata = []
            
            #     # purchaseobj=MagazinePurchaseInfo.objects.filter(users=userid)
            #     purchaseobj=MagazinePurchaseInfo.objects.filter(users=userid,is_buyed=True)
            #     purchasedata = MagazinePurchaseInfoSerializer(purchaseobj,many=True).data

            #     # bookmarkobj=MagazineBookmark.objects.filter(users=userid, is_bookmark = True)
            #     bookmarkobj=MagazineBookmark.objects.filter(users=userid).values_list('magazines',flat=True)
            #     bookmarkobj=MagazineInfo.objects.filter(id__in=bookmarkobj)
            #     bookmarkdata = magazineliberarySerializer(bookmarkobj,many=True,context={'user_id':userid}).data

            #     favouriteobj=MagazineFavorite.objects.filter(users=userid).values_list('magazines',flat=True)
            #     favouriteobj=MagazineInfo.objects.filter(id__in=bookmarkobj)
            #     favouritedata = magazineliberarySerializer(favouriteobj,many=True,context={'user_id':userid}).data

            #     dict={"Bookmark":bookmarkdata,"Purchase":purchasedata,"Favourite":favouritedata}
            #     context = {'status': 1,'message':alldata_message['message'],'data':dict}

            # return Response(context, status=status.HTTP_200_OK)

###############################################
                bookmarkdata = []
                favouritedata = []
                purchasedata = []
                library_all = []
            
                purchaseobj=MagazinePurchaseInfo.objects.filter(users=userid).values_list('magazineInfos',flat=True)
                # purchasedata = MagazinePurchaseInfoSerializer(purchaseobj,many=True).data

                # bookmarkobj=MagazineBookmark.objects.filter(users=userid, is_bookmark = True)
                bookmarkobj=MagazineBookmark.objects.filter(users=userid).values_list('magazines',flat=True)
                # bookmarkobj=MagazineInfo.objects.filter(id__in=bookmarkobj)
                # bookmarkdata = magazineliberarySerializer(bookmarkobj,many=True).data

                favouriteobj=MagazineFavorite.objects.filter(users=userid).values_list('magazines',flat=True)
                # favouriteobj=MagazineInfo.objects.filter(id__in=bookmarkobj)
                # favouritedata = magazineliberarySerializer(favouriteobj,many=True).data

                all_liberary = set(purchaseobj).union(set(bookmarkobj)).union(set(favouriteobj))
                all_liberary_obj=MagazineInfo.objects.filter(id__in=list(all_liberary),is_aproved=True,is_active=True)
                library_all = magazineliberarySerializer(all_liberary_obj,many=True).data

                # dict={"Bookmark":bookmarkobj,"Purchase":purchasedata,"Favourite":favouritedata,'liberary_all':all_liberary}
                # dict={'all_liberary':all_liberary}
                dict={"Bookmark":bookmarkdata,"Purchase":favouritedata,"Favourite":purchasedata,'library_all':library_all}
                context = {'status': 1,'message':alldata_message['message'],'data':dict}

            return Response(context, status=status.HTTP_200_OK)
        except Exception as e:
            logger.error('MyLibraryAPIView:error => ' + str(e))
            context = {'status': 0, 'message': Exp_MESSAGE['message']}
            return Response(context, status=status.HTTP_400_BAD_REQUEST)



# server magazine search 
class MagazineSearchAPIView(generics.ListAPIView):
    # queryset = MagazineInfo.objects.all().order_by('name','author__author_name','system_category__category_name','magazine_category__category_name')
    queryset = MagazineInfo.objects.filter(is_aproved=True,is_active=True).all().order_by('name','author__author_name','system_category__category_name','magazine_category__category_name')
    # queryset = MagazineInfo.objects.all()
    serializer_class = SearchMagazineDetailSerializer
    filter_backends = [filters.SearchFilter]
    search_fields = ['name','author__author_name','system_category__category_name','magazine_category__category_name']

    def list(self, request, *args, **kwargs):
        try:
            search = self.request.query_params.get('search', None)

            if search:
                search_info = SearchMagazineinfo.objects.filter(title__icontains=search).last()
                if search_info:
                    SearchMagazineinfo.objects.filter(title__icontains=search).update(count=F("count") + 1)
                    response = super().list(request, *args, **kwargs)
                    response.data = {'status': 1, 'message': search_message['message'],'data': response.data}
                    return response
                else:
                    searchobj=MagazineInfo.objects.filter(Q(name__icontains=search)|Q(author__author_name__icontains=search)|Q(system_category__category_name__icontains=search)|Q(magazine_category__category_name__icontains=search)).last()
                    if searchobj:
                        searchid=SearchMagazineinfo.objects.create(title=search)
                        SearchMagazineinfo.objects.filter(id = searchid.id).update(magazineInfos = searchobj.id)
                        response = super().list(request, *args, **kwargs)
                        response.data = {'status': 1, 'message': search_message['message'],'data': response.data}
                        return response
                    response = super().list(request, *args, **kwargs)
                    response.data = {'status': 1, 'message': search_message['message'],'data': response.data}
                    return response
            else:
                search_info = SearchMagazineinfo.objects.all().values().order_by('-count')[:5:]

                # purchase_info = MagazinePurchaseInfo.objects.all().order_by('-magazineInfos')[:10:]
                # purchase_info = MagazinePurchaseInfo.objects.filter(is_buyed=True).order_by('-magazineInfos')[:10:]
                querset = MagazinePurchaseInfo.objects.all()
                purchase_info = querset.annotate(truck_count=Count('magazineInfos')).order_by('-truck_count')[:10:]

                serializer = MagazinePurchaseInfoSerializer(purchase_info,many=True).data
                dict11={'search_data':search_info,'puchase_data':serializer}
                # dict11={'puchase_data':serializer}
                response = super().list(request, *args, **kwargs)
                response.data = {'status': 1, 'message': search_message['message'],'data': dict11 }
                return response

        except Exception as e:
            logger.error('MagazineSearchAPIView:error => ' + str(e))
            context = {'status': 0, 'message': str(e)}
            return Response(context, status=status.HTTP_400_BAD_REQUEST)



# # new searchw from atrhor magazine search 
# class MagazineSearchAPIView(generics.ListAPIView):
#     queryset = MagMapAuthor.objects.all()
#     # queryset = MagazineInfo.objects.all()
#     serializer_class = MagMapAuthorSerializer
#     filter_backends = [filters.SearchFilter]
#     search_fields = ['magazine__name','author__author_name','magazine__system_category__category_name','magazine__magazine_category__category_name']
#     def list(self, request, *args, **kwargs):
#         try:
#             search = self.request.query_params.get('search', None)

#             if search:
#                 search_info = SearchMagazineinfo.objects.filter(title__icontains=search).last()
#                 if search_info:
#                     SearchMagazineinfo.objects.filter(title__icontains=search).update(count=F("count") + 1)
#                     response = super().list(request, *args, **kwargs)
#                     response.data = {'status': 1, 'message': search_message['message'],'data': response.data}
#                     return response
#                 else:
#                     searchobj=MagazineInfo.objects.filter(Q(name__icontains=search)|Q(author__author_name__icontains=search)|Q(system_category__category_name__icontains=search)|Q(magazine_category__category_name__icontains=search)).last()
#                     if searchobj:
#                         searchid=SearchMagazineinfo.objects.create(title=search)
#                         SearchMagazineinfo.objects.filter(id = searchid.id).update(magazineInfos = searchobj.id)
#                         response = super().list(request, *args, **kwargs)
#                         response.data = {'status': 1, 'message': search_message['message'],'data': response.data}
#                         return response
#                     response = super().list(request, *args, **kwargs)
#                     response.data = {'status': 1, 'message': search_message['message'],'data': response.data}
#                     return response
                    
#             else:

#                 # search_info = SearchMagazineinfo.objects.all().values().order_by('-count')[:5:]
#                 print()
                # purchase_info = MagazinePurchaseInfo.objects.all().values_list('magazineInfos', flat=True).distinct()
                # purchase_info = MagazinePurchaseInfo.objects.filter(id__in = purchase_info).order_by('-magazineInfos')[:10:]

#                 serializer = MagazinePurchaseInfoSerializer(purchase_info,many=True).data
#                 # dict11={'search_data':search_info,'puchase_data':serializer}
#                 dict11={'puchase_data':serializer}
#                 response = super().list(request, *args, **kwargs)
#                 response.data = {'status': 1, 'message': search_message['message'],'data': dict11 }
#         #         return response

#         except Exception as e:
#             logger.error('MagazineSearchAPIView:error => ' + str(e))
#             context = {'status': 0, 'message': str(e)}
#             return Response(context, status=status.HTTP_400_BAD_REQUEST)

# # Test magazine search 
# class MagazineSearchAPIView(generics.ListAPIView):
#     queryset = MagMapAuthor.objects.all()
#     serializer_class = MagMapAuthorSerializer
#     filter_backends = [filters.SearchFilter]
#     search_fields = ['magazine__name','author__author_name','magazine__system_category__category_name','magazine__magazine_category__category_name']

#     def list(self, request, *args, **kwargs):
#         try:
#             search = self.request.query_params.get('search', None)

#             if search:

#                 #####################
#                 authobj = Author.objects.filter(author_name=search).values_list('id',flat=True)
#                 print(authobj,'====authobj===')
#                 mapauthor = MagMapAuthor.objects.filter(author__in=authobj)
#                 print(mapauthor,'======mapauthor=======')
#                 #####################

#                 search_info = SearchMagazineinfo.objects.filter(title__icontains=search).last()
#                 if search_info:
#                     SearchMagazineinfo.objects.filter(title__icontains=search).update(count=F("count") + 1)
#                     response = super().list(request, *args, **kwargs)
#                     response.data = {'status': 1, 'message': search_message['message'],'data': response.data}
#                     return response

#                 else:

#                     # #####################
#                     # authobj = Author.objects.filter(author_name=search).values_list('id',flat=True)
#                     # print(authobj,'====authobj===')
#                     # mapauthor = MagMapAuthor.objects.filter(author__in=authobj)
#                     # print(mapauthor,'======mapauthor=======')
#                     # #####################

#                     searchobj=MagMapAuthor.objects.filter(Q(magazine__name__icontains=search)|Q(author__author_name__icontains=search)|Q(magazine__system_category__category_name__icontains=search)|Q(magazine__magazine_category__category_name__icontains=search)).last()
#                     if searchobj:
#                         searchid=SearchMagazineinfo.objects.create(title=search)
#                         SearchMagazineinfo.objects.filter(id = searchid.id).update(magazineInfos = searchobj.id)
#                         response = super().list(request, *args, **kwargs)
#                         response.data = {'status': 1, 'message': search_message['message'],'data': response.data}
#                         return response
#                     response = super().list(request, *args, **kwargs)
#                     response.data = {'status': 1, 'message': search_message['message'],'data': response.data}
#                     return response  
#             else:
#                 search_info = SearchMagazineinfo.objects.all().values().order_by('-count')[:5:]
#                 purchase_info = MagazinePurchaseInfo.objects.all().order_by('-magazineInfos')[:10:]
#                 serializer = MagazinePurchaseInfoSerializer(purchase_info,many=True).data

#                 dict11={'search_data':search_info,'puchase_data':serializer}
#                 response = super().list(request, *args, **kwargs)
#                 response.data = {'status': 1, 'message': search_message['message'],'data': dict11 }
#                 return response

#         except Exception as e:
#             logger.error('MagazineSearchAPIView:error => ' + str(e))
#             context = {'status': 0, 'message': str(e)}
#             return Response(context, status=status.HTTP_400_BAD_REQUEST)

# # Test magazine search 
# class MagazineSearchAPIView(generics.ListAPIView):
#     queryset = MagMapAuthor.objects.all()
#     serializer_class = MagMapAuthorSerializer
#     filter_backends = [filters.SearchFilter]
#     search_fields = ['magazine__name','author__author_name','magazine__system_category__category_name','magazine__magazine_category__category_name']

#     def list(self, request, *args, **kwargs):
#         try:
#             search = self.request.query_params.get('search', None)

#             if search:

#                 #####################
#                 authobj = Author.objects.filter(author_name=search).values_list('id',flat=True)
#                 print(authobj,'====authobj===')
#                 mapauthor = MagMapAuthor.objects.filter(author__in=authobj).values_list('magazine',flat=True)
#                 print(mapauthor,'======mapauthor=======')
#                 #####################

#                 search_info = SearchMagazineinfo.objects.filter(title__icontains=search).last()
#                 if search_info:
#                     SearchMagazineinfo.objects.filter(title__icontains=search).update(count=F("count") + 1)
#                     response = super().list(request, *args, **kwargs)
#                     response.data = {'status': 1, 'message': search_message['message'],'data': response.data}
#                     return response

#                 else:

#                     # #####################
#                     # authobj = Author.objects.filter(author_name=search).values_list('id',flat=True)
#                     # print(authobj,'====authobj===')
#                     # mapauthor = MagMapAuthor.objects.filter(author__in=authobj)
#                     # print(mapauthor,'======mapauthor=======')
#                     # #####################

#                     searchobj=MagMapAuthor.objects.filter(Q(magazine__name__icontains=search)|Q(author__author_name__icontains=search)|Q(magazine__system_category__category_name__icontains=search)|Q(magazine__magazine_category__category_name__icontains=search)).last()
#                     if searchobj:
#                         searchid=SearchMagazineinfo.objects.create(title=search)
#                         SearchMagazineinfo.objects.filter(id = searchid.id).update(magazineInfos = searchobj.id)
#                         response = super().list(request, *args, **kwargs)
#                         response.data = {'status': 1, 'message': search_message['message'],'data': response.data}
#                         return response
#                     response = super().list(request, *args, **kwargs)
#                     response.data = {'status': 1, 'message': search_message['message'],'data': response.data}
#                     return response  
#             else:
#                 search_info = SearchMagazineinfo.objects.all().values().order_by('-count')[:5:]
#                 purchase_info = MagazinePurchaseInfo.objects.all().order_by('-magazineInfos')[:10:]
#                 serializer = MagazinePurchaseInfoSerializer(purchase_info,many=True).data

#                 dict11={'search_data':search_info,'puchase_data':serializer}
#                 response = super().list(request, *args, **kwargs)
#                 response.data = {'status': 1, 'message': search_message['message'],'data': dict11 }
#                 return response

#         except Exception as e:
#             logger.error('MagazineSearchAPIView:error => ' + str(e))
#             context = {'status': 0, 'message': str(e)}
#             return Response(context, status=status.HTTP_400_BAD_REQUEST)

# No Search  Api
class NoSearchAPIView(generics.ListAPIView):
    serializer_class = SearchMagazineDetailSerializer
    def get(self,request,id=None):
        try:
            search = self.request.query_params.get('search', None)
            if not search:
                dict={'search_data':[],'puchase_data':[]}
                context = {'status': 1,'message': nosearch_message['message'],'data':dict}
                return Response(context, status=status.HTTP_200_OK)
            else:
                context = {'status': 0,'message': nosearch_error_message['message'],}
                return Response(context, status=status.HTTP_200_OK)
        except Exception as e:
            logger.error('NoSearchAPIView:error => ' + str(e))
            context = {'status': 0, 'message': str(e)}
            return Response(context, status=status.HTTP_400_BAD_REQUEST)



# Magazine Purchase Info Api
class MagazinePurchaseInfoAPIView(generics.GenericAPIView):
    serializer_class = MagazinePurchaseInfodataSerializer

    def get(self, request,id=None):
        try:
            user_id = self.request.query_params.get('user_id', None)
            if not user_id:
                context = {'status': 0,'message':'Please enter correct user id.'}
                return Response(context, status=status.HTTP_200_OK)
            purchadata=MagazinePurchaseInfo.objects.filter(users=user_id).last()
            if not purchadata:
                context = {'status': 0,'message':'Record is not available.'}
                return Response(context, status=status.HTTP_200_OK)    
            serializers = MagazinePurchaseInfodataSerializer(purchadata,many=False)
            context = {'status': 1,'message':'magazine purchase data found successfully','data':serializers.data}
            return Response(context, status=status.HTTP_200_OK)

        except Exception as e:
            logger.error('MagazinePurchaseInfoAPIView:error => ' + str(e))
            context = {'status': 0, 'message': Exp_MESSAGE['message']}
            return Response(context, status=status.HTTP_400_BAD_REQUEST)

  # server code post

    def post(self,request,id=None):
        try:
            request.data['users']=request.data['user_id']
            request.data['magazineInfos']=request.data.get('magazine_id',None)
            # request.data['magazineInfos']=None if request.data['magazine_id']==0 else request.data['magazine_id']
            request.data['currency']=request.data.get('currency',None)
            request.data['transaction_id']=request.data['transaction_id']

            try:
                lastid = MagazinePurchaseInfo.objects.latest('id')
            except MagazinePurchaseInfo.DoesNotExist:
                lastid = '001'
            code = f"MAG{request.data['magazineInfos']}{lastid.id}"
            request.data['purchases_order_id']=code
            request.data['purchases_order_id']=request.data['purchases_order_id']

            magazineobj =  MagazineInfo.objects.filter(id=request.data['magazineInfos']).last()

            # request.data['is_buyed']=False if request.data['is_buyed'] == "" else True
            # request.data['is_rented']=False if request.data['is_rented'] == "" else True
            # request.data['is_subscription']=False if request.data['is_subscription'] == "" else True

            if request.data['is_buyed'] == True:

                request.data['buy_date']=datetime.datetime.now()
                request.data['buy_price']=request.data['price']
                
                request.data['offer_max_amount']=request.data.get('offer_max_amount',None)
                request.data['offer_discount_amount']=request.data.get('offer_discount_amount',None)

                request.data['offer_id']=request.data.get('offer_id',None)
                request.data['offer_code']=request.data.get('offer_code',None)

                # current_date = datetime.datetime.now().date()
                # userobj = MagazineOfferinfo.objects.filter(Q(id__icontains=coupon_id)|Q(code__icontains=coupon_id)).last()

                # if userobj.start_date <=current_date <= userobj.end_date:

                if request.data['offer_id'] or request.data['offer_code']:
                    offer_code = request.data['offer_code']

                    current_date = datetime.datetime.now().date()
                    couponobj =  MagazineOfferinfo.objects.filter(Q(id=request.data['offer_id'])|Q(code__iexact=offer_code if offer_code else "")).last()
                    if not couponobj.start_date <=current_date <= couponobj.end_date:

                        context = {'status': 0,'message':'Coupon code has been expired, Please try again.',}
                        return Response(context, status=status.HTTP_200_OK)

                    request.data['magazineOffer']=couponobj.id
                    offerobj=float(float(request.data['buy_price'])*float(couponobj.discount)/100)
                    offerprice=float(request.data['buy_price'])-float(offerobj)
                    request.data['offer_discount'] = couponobj.discount
                    request.data['offer_discount_amount'] = round(offerobj, 2)
                    request.data['offer_price'] = round(offerprice, 2)
                    request.data['is_offered'] = True

                buyobj = MagazinePurchaseInfo.objects.filter(users=request.data['user_id'],magazineInfos=request.data['magazineInfos'],is_buyed=True).last()
                if buyobj:
                    context = {'status': 0,'message':'User has been already taken buy.'}
                    return Response(context, status=status.HTTP_200_OK)

                # substime= MagazinePurchaseInfo.objects.filter(users=request.data['users'],is_buyed=True,subscription_user_status=True).last()
                # if substime:
                #     context = {'status': 1,'message':'User has been already taken buy',}
                #     return Response(context, status=status.HTTP_200_OK)

                serializer = CreatepurchageSerializer(data=request.data)
                if serializer.is_valid():
                    magid=serializer.save()
                    mgview = MagazinePurchaseInfo.objects.filter(id=magid.id).last()
                    serializers_views = ShowPurchaseSerializer(mgview)
                    
                    ### FCM Token through send notification.
                    user_id = request.data['user_id']
                    userdetails = User.objects.filter(id=user_id).last()
                    title = 'Magazine Purchase'
                    msg = f'Hi {userdetails.first_name}, you have been purchased {magazineobj.name} magazine successfully.'
                    send_push_notification(user_id, title, msg)
                    ############

                    record_data = {'username':userdetails.username,'message':msg, 'name':userdetails.first_name}
                    BuyMailToUserThread(record_data).start()

                    context = {'status': 1,'message':'Magazine purchase record create successfully','data':serializers_views.data}
                    return Response(context, status=status.HTTP_200_OK)

                else:

                    context = {'status': 0,'message':'Magazine purchase record is not available.','data':serializer.errors}
                    return Response(context, status=status.HTTP_200_OK)

                
            elif request.data['is_rented'] == True:

                request.data['rent_date']=datetime.datetime.now()
                request.data['rent_expiry_date']=datetime.datetime.now() + datetime.timedelta(days=15)
                # request.data['rent_price']= 2000
                request.data['rent_price']= float(request.data.get('price',None))

                # substime= MagazinePurchaseInfo.objects.filter(users=request.data['users'],is_rented=True,subscription_user_status=True).last()
                # if substime:
                #     context = {'status': 1,'message':'User has been already taken rent',}
                #     return Response(context, status=status.HTTP_200_OK)

                rentobj = MagazinePurchaseInfo.objects.filter(users=request.data['user_id'],magazineInfos=request.data['magazineInfos'],is_rented=True,subscription_user_status=True).last()
                if rentobj:
                    context = {'status': 1,'message':'User has been already taken rent.'}
                    return Response(context, status=status.HTTP_200_OK)

                serializer = CreatepurchageSerializer(data=request.data)
                if serializer.is_valid():
                    magid=serializer.save()
                    mgview = MagazinePurchaseInfo.objects.filter(id=magid.id).last()
                    serializers_views = ShowPurchaseSerializer(mgview)

                    ### FCM Token through send notification.
                    user_id = request.data['user_id']
                    userdetails = User.objects.filter(id=user_id).last()
                    title = 'Magazine Purchase'
                    msg = f'Hi {userdetails.first_name}, you have been rented {magazineobj.name}  magazine successfully.'
                    send_push_notification(user_id, title, msg)
                    ############

                    record_data = {'username':userdetails.username,'message':msg, 'name':userdetails.first_name}
                    BuyMailToUserThread(record_data).start()

                    context = {'status': 1,'message':'Magazine rent record create successfully','data':serializers_views.data}
                    return Response(context, status=status.HTTP_200_OK)
                else:
                    context = {'status': 0,'message':'Magazine purchase record is not available.','data':serializer.errors}
                    return Response(context, status=status.HTTP_200_OK)

            elif request.data['is_subscription'] == True:
                request.data['rent_date']=datetime.datetime.now()
                request.data['magazineInfos']=11

                subcriptio_id=request.data['subscription_type']

                subscriptionobj = SubscriptionType.objects.filter(id=subcriptio_id).last()
                request.data['subscription'] = subscriptionobj.id
                if not subscriptionobj:
                    context = {'status': 0,'message':'subcription id is not match'}
                    return Response(context, status=status.HTTP_200_OK)
                subtype=subscriptionobj.subscription_type

                request.data['months']=str(subscriptionobj.days)+str(' ')+str('months')
                q=subscriptionobj.days
                p=30*int(q)
                request.data['rent_expiry_date']=datetime.datetime.now() + datetime.timedelta(days=p)

                request.data['subscription_price']=subscriptionobj.price

                substime= MagazinePurchaseInfo.objects.filter(users=request.data['users'],is_subscription=True,subscription_user_status=True).last()
                if substime:
                    context = {'status': 1,'message':'User has been already taken subscription',}
                    return Response(context, status=status.HTTP_200_OK)

                serializer = CreatepurchageSerializer(data=request.data)
                if serializer.is_valid():
                    MagazinePurchaseInfo.objects.filter(users=request.data['users'],is_subscription=True, subscription_user_status=True).update(subscription_user_status=False)
                    magid=serializer.save()

                    # substime= MagazinePurchaseInfo.objects.filter(users=request.data['users'],is_subscription=True,subscription_user_status=True).last()
                    # if substime:
                    #     context = {'status': 1,'message':'User has been already taken subscription',}
                    #     return Response(context, status=status.HTTP_200_OK)

                    mgview = MagazinePurchaseInfo.objects.filter(id=magid.id).last()
                    serializers_views = ShowPurchaseSerializer(mgview)

                    ### FCM Token through send notification.
                    user_id = request.data['user_id']
                    userdetails = User.objects.filter(id=user_id).last()
                    title = 'Magazine Purchase'
                    msg = f'Hi {userdetails.first_name}, you have been subscripted magazines successfully.'
                    send_push_notification(user_id, title, msg)
                    ############

                    record_data = {'username':userdetails.username,'message':msg, 'name':userdetails.first_name}
                    BuyMailToUserThread(record_data).start()

                    context = {'status': 1,'message':'Magazine subscription record create successfully','data':serializers_views.data}
                    return Response(context, status=status.HTTP_200_OK)
                else:
                    context = {'status': 0,'message':'Magazine purchase record is not available.','data':serializer.errors}
                    return Response(context, status=status.HTTP_200_OK)


            elif request.data['is_hard_copy'] == True:

                # request.data['rent_date']=datetime.datetime.now()
                request.data['hard_copy_price']=request.data['price']
                
                request.data['offer_max_amount']=request.data.get('offer_max_amount',None)
                request.data['offer_discount_amount']=request.data.get('offer_discount_amount',None)

                request.data['offer_id']=request.data.get('offer_id',None)
                request.data['offer_code']=request.data.get('offer_code',None)

                # current_date = datetime.datetime.now().date()
                # userobj = MagazineOfferinfo.objects.filter(Q(id__icontains=coupon_id)|Q(code__icontains=coupon_id)).last()

                # if userobj.start_date <=current_date <= userobj.end_date:
                 
                user = User.objects.filter(id=request.data['users']).last()
                if not user:
                    context = {'status': 0,'message':'User id is not match'}
                    return Response(context, status=status.HTTP_200_OK)

                if request.data['offer_id'] or request.data['offer_code']:
                    offer_code = request.data['offer_code']

                    current_date = datetime.datetime.now().date()
                    couponobj =  MagazineOfferinfo.objects.filter(Q(id=request.data['offer_id'])|Q(code__iexact=offer_code if offer_code else "")).last()
                    if not couponobj.start_date <=current_date <= couponobj.end_date:

                        context = {'status': 0,'message':'Coupon code has been expired, Please try again.',}
                        return Response(context, status=status.HTTP_200_OK)

                    request.data['delivery_location'] = user.address if user.address else ""
                    request.data['magazineOffer']=couponobj.id
                    offerobj=float(float(request.data['hard_copy_price'])*float(couponobj.discount)/100)
                    offerprice=float(request.data['hard_copy_price'])-float(offerobj)
                    request.data['offer_discount'] = couponobj.discount
                    request.data['offer_discount_amount'] = round(offerobj, 2)
                    request.data['offer_price'] = round(offerprice, 2)
                    request.data['is_offered'] = True

                serializer = CreatepurchageSerializer(data=request.data)
                if serializer.is_valid():
                    magid=serializer.save()
                    mgview = MagazinePurchaseInfo.objects.filter(id=magid.id).last()
                    serializers_views = ShowPurchaseSerializer(mgview)
                    
                    ### FCM Token through send notification.
                    user_id = request.data['user_id']
                    userdetails = User.objects.filter(id=user_id).last()
                    title = 'Magazine Purchase'
                    msg = f'Hi {userdetails.first_name}, you have been purchased {magazineobj.name} magazine successfully.'
                    send_push_notification(user_id, title, msg)
                    ############
                    context = {'status': 1,'message':'magazine hard record create successfully','data':serializers_views.data}
                    return Response(context, status=status.HTTP_200_OK)

                else:

                    context = {'status': 0,'message':'magazine hard copy record is not available.','data':serializer.errors}
                    return Response(context, status=status.HTTP_200_OK)
            else:
                context = {'status': 0,'message':'please enter currect status.'}
                return Response(context, status=status.HTTP_200_OK) 

        except Exception as e:
            logger.error('MagazinePurchaseInfoAPIView:error => ' + str(e))
            context = {'status': 0, 'message': str(e)}
            return Response(context, status=status.HTTP_400_BAD_REQUEST)


# Magazine Offer List Api
class MagazineOfferListAPIView(generics.GenericAPIView):
    serializer_class = MutipleMAGOfferListSerializer

    def get(self, request,id=None):
        try:
            # user_id = self.request.query_params.get('user_id', None)
            user_id = request.GET.get('user_id', None)
            current_date = datetime.datetime.now().date()
            if user_id:
                # userofferobj = UserMapOffer.objects.filter(user=user_id).all()
                useroffer = UserMapOffer.objects.filter(user=user_id).values_list('magazineoffer',flat=True)
                
                # userobj = MagazineOfferinfo.objects.filter(id__in=useroffer,end_date__gte=current_date)
                userobj = MagazineOfferinfo.objects.filter(id__in=useroffer,end_date__gte=current_date)
                userobj1 = MagazineOfferinfo.objects.filter(for_users__icontains="All",end_date__gte=current_date)
                offerobj = list((set(userobj)).union(set(userobj1)))
                # userobj = MagazineOfferinfo.objects.filter().last()

                serializers = self.serializer_class(offerobj,many=True)
                context = {'status': 1,'message':offer_message['message'],'data':serializers.data}
                return Response(context, status=status.HTTP_200_OK)

            # userofferobj = UserMapOffer.objects.all()
            userobj = MagazineOfferinfo.objects.filter(end_date__gte=current_date)
            serializers = self.serializer_class(userobj,many=True)
            context = {'status': 1,'message':offer_message['message'],'data':serializers.data}
            return Response(context, status=status.HTTP_200_OK)

        except Exception as e:
            logger.error('MagazineOfferListAPIView:error => ' + str(e))
            context = {'status': 0, 'message': Exp_MESSAGE['message']}
            return Response(context, status=status.HTTP_400_BAD_REQUEST)

# class MagazineOfferListAPIView(generics.GenericAPIView):
#     serializer_class = MAGOfferListSerializer

#     def get(self, request,id=None):
#         try:
#             # user_id = self.request.query_params.get('user_id', None)
#             user_id = request.GET.get('user_id', None)
#             if user_id:
#                 userofferobj = MagazineOfferinfo.objects.filter(users__isnull = True).all()
#                 userofferobj1 = MagazineOfferinfo.objects.filter(users=user_id).all()

#                 offerobj = list((set(userofferobj)).union(set(userofferobj1)))
#                 serializers = self.serializer_class(offerobj,many=True)
#                 context = {'status': 1,'message':offer_message['message'],'data':serializers.data}
#                 return Response(context, status=status.HTTP_200_OK)

#             userofferobj = MagazineOfferinfo.objects.filter(users__isnull = True).all()
#             serializers = self.serializer_class(userofferobj,many=True)
#             context = {'status': 1,'message':offer_message['message'],'data':serializers.data}
#             return Response(context, status=status.HTTP_200_OK)

#         except Exception as e:
#             logger.error('MagazineOfferListAPIView:error => ' + str(e))
#             context = {'status': 0, 'message': Exp_MESSAGE['message']}
#             return Response(context, status=status.HTTP_400_BAD_REQUEST)


# server Test Magazine Offer validation Api
class MAGOfferInfoAPIView(generics.GenericAPIView):
    serializer_class = MAGOfferListSerializer

    def get(self, request,id=None):
        try:
            amount = request.GET.get('amount', None)
            coupon_id = request.GET.get('coupon_id', None)
            user_id = request.GET.get('user_id',None)
            try:

                offerobj = MagazineOfferinfo.objects.filter(Q(id__iexact=coupon_id)|Q(code__iexact=coupon_id)).last()
            except MagazineOfferinfo.DoesNotExist:
                offerobj = None
            if not offerobj:
                context = {'status': 0,'message':'Please enter correct offer id or offer code.'}
                return Response(context, status=status.HTTP_200_OK)

            if user_id is None:
                context = {'status': 0,'message':'Please enter correct user id.'}
                return Response(context, status=status.HTTP_200_OK)

            ## If User aplied allready coupan code. by jay sir
            # check_user_coupan = UserMapOffer.objects.filter(magazineoffer_id=offerobj.id, user_id=user_id).last()
            # if check_user_coupan:
            #     context = {'status': 0,'message':'User is already use coupon code.'}
            #     return Response(context, status=status.HTTP_200_OK)

            dic={}
            current_date = datetime.datetime.now().date()
            userobj = MagazineOfferinfo.objects.filter(Q(id__iexact=coupon_id)|Q(code__iexact=coupon_id)).last()

            # ###############################
            # offerobj = MagazinePurchaseInfo.objects.filter(users=user_id,magazineOffer=userobj.id)
            # if offerobj:
            #     context = {'status': 0,'message':'User is already use coupon code.'}
            #     return Response(context, status=status.HTTP_200_OK)
            # ###########################

            if userobj.start_date <=current_date <= userobj.end_date:
                ###############################
                offerobj = MagazinePurchaseInfo.objects.filter(users=user_id,magazineOffer=userobj.id)
                if offerobj:
                    context = {'status': 0,'message':'This coupon code is already used.'}
                    return Response(context, status=status.HTTP_200_OK)
                ###########################
                if amount:
                    percentage=float(float(amount)*float(userobj.discount)/100)
                    offerpr=float(amount)-float(percentage)
                    offerprice=round(offerpr, 2)

                    offer = MagazineOfferinfo.objects.filter(Q(id__iexact=coupon_id)|Q(code__iexact=coupon_id)).last()
                    dic={'id':offer.id,'real_price':amount,'offer_price':offerprice,'discount_price':round(percentage,2),'code':offer.code,'discount':offer.discount,'max_discount':offer.max_discount,'start_date':offer.start_date,'end_date':offer.end_date,'offer_status':offer.offer_status,'description':offer.description,'created_on':offer.created_on,'updated_on':offer.updated_on}
                    context = {'status': 1,'message':offer_message['message'],'data':[dic]}
                    return Response(context, status=status.HTTP_200_OK)

                offer = MagazineOfferinfo.objects.filter(Q(id__iexact=coupon_id)|Q(code__iexact=coupon_id)).last()
                dic={'id':offer.id,'real_price':None,'offer_price':None,'discount_price':None,'code':offer.code,'discount':offer.discount,'max_discount':offer.max_discount,'start_date':offer.start_date,'end_date':offer.end_date,'offer_status':offer.offer_status,'description':offer.description,'created_on':offer.created_on,'updated_on':offer.updated_on}
                context = {'status': 1,'message':offer_message['message'],'data':[dic]}
                return Response(context, status=status.HTTP_200_OK)

            MagazineOfferinfo.objects.filter(Q(id__iexact=coupon_id)|Q(code__iexact=coupon_id)).update(offer_status=False)
            context = {'status': 0,'message':'Coupon code has been expired, Please try again.',}
            return Response(context, status=status.HTTP_200_OK)

        except Exception as e:
            logger.error('MAGOfferInfoAPIView:error => ' + str(e))
            context = {'status': 0, 'message': Exp_MESSAGE['message']}
            return Response(context, status=status.HTTP_400_BAD_REQUEST)
        

# Magazine Subscribtion Api
class MagazineSubscriptionInfoAPIView(generics.GenericAPIView):
    serializer_class = MagazineSubscriptionInfoSerializer

    def get(self, request,id=None):
        try:
            user_id = request.GET.get('user_id', None)
            if user_id:
                mysublist = Subscription.objects.filter(users=user_id).all()
                serializerdata = self.serializer_class(mysublist,many=True)
                context = {'status': 1,'message':subscribtion_message['message'],'data':serializerdata.data}
                return Response(context, status=status.HTTP_200_OK)

            subscriptionobj = Subscription.objects.all()
            serializers = SubscriptionSerializer(subscriptionobj,many=True)
            context = {'status': 1,'message':subscribtion_message['message'],'data':serializers.data}
            return Response(context, status=status.HTTP_200_OK)

        except Exception as e:
            logger.error('MagazineSubscriptionInfoAPIView:error => ' + str(e))
            context = {'status': 0, 'message': Exp_MESSAGE['message']}
            return Response(context, status=status.HTTP_400_BAD_REQUEST)


# server Magazine Subscribtion list Api
class MagazineSubscriptionListAPIView(generics.GenericAPIView):
    serializer_class = UserPurchCountrySerializer

    def get(self, request,id=None):
        try:
            user_id = request.GET.get('user_id', None)
            sort_name = request.GET.get('sort_name', None)
            if user_id and not sort_name:
                userlist = User.objects.filter(id=user_id).first()
                serializer = UserPurchaseListSerializer(userlist, many=False)
                context = {'status': 1,'message':subscribtion_message['message'],'data':serializer.data}
                return Response(context, status=status.HTTP_200_OK)

            if sort_name and not user_id:
                countryonj = Country.objects.filter(sortname=sort_name).last()
                subscriptionobj = SubscriptionType.objects.filter(country=countryonj.id,subscription_status=1).all()
                countryserializer = CountryListUserSerializer(subscriptionobj, many=True)
                dict={'user_subscription': [] ,'subscription_list':countryserializer.data}
                context = {'status': 1,'message':subscribtion_message['message'],'data':dict}
                return Response(context, status=status.HTTP_200_OK)

            if user_id and sort_name:
                try:
                    countryonj = Country.objects.filter(sortname=sort_name).last()
                    subscriptionobj1 = SubscriptionType.objects.filter(country=countryonj.id).values_list('id', flat=True)
                    mysubl = MagazinePurchaseInfo.objects.filter(users=user_id,is_subscription=True,subscription_user_status=True, subscription__in=subscriptionobj1).all()
                except Exception:
                    mysubl = MagazinePurchaseInfo.objects.none()

                subobj = MagazinePurchaseInfo.objects.filter(users=user_id,is_subscription=True).last()
                if not subobj:
                    serializerdata = ListUserSerializer(mysubl,many=True)
                serializerdata = SListUserSerializer(mysubl,many=True)
                

                #############################
                # current_date = datetime.datetime.now()
                # purchase = MagazinePurchaseInfo.objects.filter(users=user_id,is_subscription=True,subscription_user_status=True).last()
                # duration = purchase.rent_date <=current_date <= purchase.rent_expiry_date
                # if purchase and duration:
                #     print('========True===========>>>>>>>>>>>')
                #     SubscriptionType.objects.filter(id=purchase.subscription.id).update(subscription_type=True)
                # print('=======false===========')
                # SubscriptionType.objects.filter(id=purchase.subscription).update(subscription_type=False)
                ############################

                subscriptionobj = SubscriptionType.objects.filter(country=countryonj.id,subscription_status=True).all()
                countryserializer = CountryListUserSerializer(subscriptionobj, many=True,context={'user_id':user_id })
                # user_subscription = [(serializerdata.data)] if serializerdata.data else []

                dict={'user_subscription': serializerdata.data ,'subscription_list':countryserializer.data}
                context = {'status': 1,'message':subscribtion_message['message'],'data':dict}
                return Response(context, status=status.HTTP_200_OK)
            else:
                context = {'status': 0,'message':'Invalid terms'}
                return Response(context, status=status.HTTP_200_OK)

        except Exception as e:
            logger.error('MagazineSubscriptionListAPIView:error => ' + str(e))
            context = {'status': 0, 'message': Exp_MESSAGE['message']}
            return Response(context, status=status.HTTP_400_BAD_REQUEST)


# Get Magazine Order History  Api
class ShowMagazineOrderHistoryAPIView(generics.GenericAPIView):
    serializer_class = MGAOrderHistorySerializer
    def get(self, request,id=None):
        try:
            user_id = self.request.query_params.get('user_id', None)

            if not user_id:
                context = {'status': 0,'message':'please enter user id.'}
                return Response(context, status=status.HTTP_200_OK)
                
            userobj = User.objects.filter(id=user_id).last()
            if not userobj:
                context = {'status': 0,'message':'record is not available.'}
                return Response(context, status=status.HTTP_200_OK)

            userdata = MagazinePurchaseInfo.objects.filter(users=user_id).all().order_by('-id')
            # userdata = MagazinePurchaseInfo.objects.filter(users=user_id).all().order_by('-id').distinct('magazineInfos')
            serializers = MGAOrderHistorySerializer(userdata,many=True)
            context = {'status': 1,'message': order_history_message['message'],'data':serializers.data}
            return Response(context, status=status.HTTP_200_OK)  

        except Exception as e:
            logger.error('ShowMagazineOrderHistoryAPIView:error => ' + str(e))
            context = {'status': 0, 'message': Exp_MESSAGE['message']}
            return Response(context, status=status.HTTP_400_BAD_REQUEST)

# Magazine Order detail  Api
class MagazineOrderDetailAPIView(generics.GenericAPIView):
    serializer_class = MagazineOrderDetailSerializer
    def get(self, request,id=None):
        try:
            user_id = self.request.query_params.get('user_id', None)
            order_id = self.request.query_params.get('order_id', None)

            if not user_id:
                context = {'status': 0,'message':'please enter user id.'}
                return Response(context, status=status.HTTP_200_OK)
            if not order_id:
                context = {'status': 0,'message':'please enter order id.'}
                return Response(context, status=status.HTTP_200_OK)
                
            userobj = User.objects.filter(id=user_id).last()
            if not userobj:
                context = {'status': 0,'message':'record is not available.'}
                return Response(context, status=status.HTTP_200_OK)

            orderobj = MagazinePurchaseInfo.objects.filter(id=order_id).last()
            if not orderobj:
                context = {'status': 0,'message':'record is not available.'}
                return Response(context, status=status.HTTP_200_OK)

            userdata = MagazinePurchaseInfo.objects.filter(id=order_id,users=user_id).all().order_by('-id')
            serializers = self.serializer_class(userdata,many=True)
            context = {'status': 1,'message': 'magazine order detail records found successfully','data':serializers.data}
            return Response(context, status=status.HTTP_200_OK)  

        except Exception as e:
            logger.error('MagazineOrderDetailAPIView:error => ' + str(e))
            context = {'status': 0, 'message': Exp_MESSAGE['message']}
            return Response(context, status=status.HTTP_400_BAD_REQUEST)


# #Magazine Order History  Api
# class MagazineOrderHistoryAPIView(generics.GenericAPIView):
#     serializer_class = MagazineOrderHistorySerializer

#     def post(self,request,id=None):
#         try:
#             data=request.data
#             data['users']=data['user_id']
#             data['magazines']=data['magazine_id']
#             data['subscriptions']=data['subscription_id']
#             data['magazineOffers']=data['magazineOffer_id']
#             data['magazinePurchase']=data['magazinePurchase_id']
            # try:
            #     lastid = MagazineOrderinfo.objects.latest('id')
            # except MagazineOrderinfo.DoesNotExist:
            #     lastid = '001'
            # code = f"MAG{data['magazines']}{lastid.id}"
            # data['transaction_id']=code

#             serializer = MagazineOrderHistorySerializer(data=data)
#             if serializer.is_valid():
#                 magid = serializer.save()
#                 mgview = MagazineOrderinfo.objects.filter(id=magid.id).last()
#                 serializers_views = MagazineOrderdataSerializer(mgview, many=False)
#                 context = {'status': 1,'message':order_message['message'],'data':serializers_views.data}
#                 return Response(context, status=status.HTTP_200_OK)
#             else:
#                 context = {'status': 0,'message':order_error_message['message']}
#                 return Response(context, status=status.HTTP_200_OK)
#         except Exception as e:
#             logger.error('MagazineOrderHistoryAPIView:error => ' + str(e))
#             context = {'status': 0, 'message': str(e)}
#             return Response(context, status=status.HTTP_400_BAD_REQUEST)


# # Get Magazine Order History  Api
# class ShowMagazineOrderHistoryAPIView(generics.GenericAPIView):
#     serializer_class = ShowMagazineOrderHistorySerializer
#     def get(self, request,id=None):
#         try:
#             user_id = self.request.query_params.get('user_id', None)

#             if not user_id:
#                 context = {'status': 0,'message':'please enter user id.'}
#                 return Response(context, status=status.HTTP_200_OK)
                
#             userobj = User.objects.filter(id=user_id).last()
#             if not userobj:
#                 context = {'status': 0,'message':'record is not available.'}
#                 return Response(context, status=status.HTTP_200_OK)

#             userdata = MagazineOrderinfo.objects.filter(users=user_id).all()
#             serializers = ShowMagazineOrderHistorySerializer(userdata,many=True)
#             context = {'status': 1,'message': order_history_message['message'],'data':serializers.data}
#             return Response(context, status=status.HTTP_200_OK)  

#         except Exception as e:
#             logger.error('ShowMagazineOrderHistoryAPIView:error => ' + str(e))
#             context = {'status': 0, 'message': Exp_MESSAGE['message']}
#             return Response(context, status=status.HTTP_400_BAD_REQUEST)



# server Magazine Reviews  Api

class MagazineReviewInfoAPIView(generics.GenericAPIView):
    serializer_class = MagazineReviewInfoSerializer

    def get(self, request,id=None):

        try:
            user_id = self.request.query_params.get('user_id', None)
            magazine_id = self.request.query_params.get('magazine_id', None)

            if not magazine_id:
                context = {'status': 0,'message':'Please enter magazine id.'}
                return Response(context, status=status.HTTP_200_OK)

            if not user_id:
                context = {'status': 0,'message':'Please enter user id.'}
                return Response(context, status=status.HTTP_200_OK)

            userobj = User.objects.filter(id=user_id)
            if not userobj:
                context = {'status': 0,'message':'Record is not available.'}
                return Response(context, status=status.HTTP_200_OK)

            magazineobj = MagazineInfo.objects.filter(id=magazine_id)
            if not magazineobj:
                context = {'status': 0,'message':'Record is not available.'}
                return Response(context, status=status.HTTP_200_OK)

            if magazine_id and user_id:
                orderobj = magazineReviewInfo.objects.filter(magazines=magazine_id,users=user_id).last()
                serializers = MagazineReviewInfoSerializer(orderobj,many=False)
                context = {'status': 1,'message':'Magazine review record found success','data':serializers.data}
                return Response(context, status=status.HTTP_200_OK)

            context = {'status': 0,'message':'Magazine review record is not found'}
            return Response(context, status=status.HTTP_200_OK)

        except Exception as e:
            logger.error('MagazineReviewInfoAPIView:error => ' + str(e))
            context = {'status': 0, 'message': Exp_MESSAGE['message']}
            return Response(context, status=status.HTTP_400_BAD_REQUEST)

    def post(self,request,id=None):
        try:
            data=request.data
            data['users']=data.get('user_id',None)
            data['magazines']=data.get('magazine_id',None)
            
            userobj = magazineReviewInfo.objects.filter(users=data['users'],magazines_id=data['magazines']).last()
            
            if userobj:
                userid = magazineReviewInfo.objects.filter(users=data['users']).first()

                serializer = self.serializer_class(userobj,data=request.data,partial=True)
                if serializer.is_valid():           
                    mgview=serializer.save()
                    serializers_views = ReviewInfoSerializer(mgview, many=False)
                    context = {'status': 1,'message':'magazine review data update successfully.','data':serializers_views.data}
                    return Response(context, status=status.HTTP_200_OK)
                else:
                    context = {'status': 0,'message':review_error_message['message']}
                    return Response(context, status=status.HTTP_200_OK)

            serializer = self.serializer_class(data=data)
            if serializer.is_valid():
                magid = serializer.save()
                mgview = magazineReviewInfo.objects.filter(id=magid.id).last()
                serializers_views = ReviewInfoSerializer(mgview, many=False)
                context = {'status': 1,'message':review_enter_message['message'],'data':serializers_views.data}
                return Response(context, status=status.HTTP_200_OK)
            else:
                context = {'status': 0,'message':review_error_message['message']}
                return Response(context, status=status.HTTP_200_OK)

        except Exception as e:
            logger.error('MagazineReviewInfoAPIView:error => ' + str(e))
            context = {'status': 0, 'message': str(e)}
            return Response(context, status=status.HTTP_400_BAD_REQUEST)

# get Magazine All Reviews  Api
class MagazineReviewInfoHistoryAPIView(generics.GenericAPIView):
    serializer_class = MagazineReviewInfoHistorySerializer

    def get(self, request,id=None):

        try:
            user_id = self.request.query_params.get('user_id', None)
            magazine_id = self.request.query_params.get('magazine_id', None)
            magazineobj = MagazineInfo.objects.filter(id=magazine_id)
            if not magazineobj:
                context = {'status': 0,'message':'Please enter correct magazine id.'}
                return Response(context, status=status.HTTP_200_OK)

            if magazine_id and user_id:
                orderobj = magazineReviewInfo.objects.filter(magazines=magazine_id,users=user_id).all()
                serializers = MagazineReviewInfoHistorySerializer(orderobj,many=True)
                context = {'status': 1,'message':allreview_error_message['message'],'data':serializers.data}
                return Response(context, status=status.HTTP_200_OK)

            if magazine_id:
                orderobj = magazineReviewInfo.objects.filter(magazines=magazine_id).all()
                serializers = MagazineReviewInfoHistorySerializer(orderobj,many=True)
                context = {'status': 1,'message':allreview_error_message['message'],'data':serializers.data}
                return Response(context, status=status.HTTP_200_OK)

            context = {'status': 0,'message':allreview_error_message['message']}
            return Response(context, status=status.HTTP_200_OK)

        except Exception as e:
            logger.error('MagazineReviewInfoHistoryAPIView:error => ' + str(e))
            context = {'status': 0, 'message': Exp_MESSAGE['message']}
            return Response(context, status=status.HTTP_400_BAD_REQUEST)


# post Magazine Read Status Api
class MagazineReadStatusInfoAPIView(generics.GenericAPIView):
    serializer_class = MagazineReadStatusSerializer


    def post(self,request):
        try:
            data=request.data
            data['magazine'] = data['magazine_id']
            data['user'] = data['user_id']
            magazineobj=MagazineInfo.objects.filter(id=data['magazine'])
            if not magazineobj:
                context = {'status': 0,'message':read_status_error_message['message']}
                return Response(context, status=status.HTTP_200_OK)

            readobj = MagazineReadStatus.objects.filter(magazine=data['magazine'],user=data['user']).last()

            if not readobj and data['is_read_status'] == True :
                MagazineReadStatus.objects.create(magazine_id=data['magazine'],user_id=data['user'])
                context = {'status': 1,'message':'success'}
                return Response(context, status=status.HTTP_200_OK)
            else:
                context = {'status': 1,'message':'success'}
                return Response(context, status=status.HTTP_200_OK)


            # if readobj is None:

            #     MagazineReadStatus.objects.filter(magazine=data['magazine'],user=data['user'],is_read_status=True).update(read_count=F("read_count") + 1)

            #     serializer = self.serializer_class(data=data)
            #     if serializer.is_valid():
            #         magid = serializer.save()
            #         mgview = MagazineReadStatus.objects.filter(id=magid.id).last()
            #         serializers_views = ShowMGAReadStatusSerializer(mgview)
            #         context = {'status': 1,'message':read_status_message['message'],'data':serializers_views.data}
            #         return Response(context, status=status.HTTP_200_OK)
            #     else:
            #         context = {'status': 0,'message':serializer.errors}
            #         return Response(context, status=status.HTTP_200_OK)
            # else:
            #     MagazineReadStatus.objects.filter(magazine=data['magazine'],user=data['user'],is_read_status=True).update(read_count=F("read_count") + 1)
            #     serializer=self.serializer_class(readobj)
            #     context = {'status': 1,'message': 'magazine read Record already create Successfully.','data':serializer.data}
            #     return Response(context, status=status.HTTP_200_OK)

        except Exception as e:
            logger.error('MagazineReadStatusInfoAPIView:error => ' + str(e))
            context = {'status': 0, 'message': str(e)}
            return Response(context, status=status.HTTP_400_BAD_REQUEST)

# get Magazine Read Status Api
class ShowMagazineReadStatusInfoAPIView(generics.GenericAPIView):
    serializer_class = MagazineReviewInfoHistorySerializer

    def get(self, request,id=None):
        try:
            user_id = self.request.query_params.get('user_id', None)
            magazine_id = self.request.query_params.get('magazine_id', None)
            magazineobj = MagazineInfo.objects.filter(id=magazine_id)
            if not magazineobj:
                context = {'status': 0,'message':'Please enter correct magazine id.'}
                return Response(context, status=status.HTTP_200_OK)

            if magazine_id and user_id:
                orderobj = MagazineReadStatus.objects.filter(magazines=magazine_id,users=user_id).all()
                serializers = self.serializer_class(orderobj,many=True)
                context = {'status': 1,'message':allreview_error_message['message'],'data':serializers.data}
                return Response(context, status=status.HTTP_200_OK)

            if magazine_id:
                orderobj = MagazineReadStatus.objects.filter(magazines=magazine_id).all()
                serializers = self.serializer_class(orderobj,many=True)
                context = {'status': 1,'message':allreview_error_message['message'],'data':serializers.data}
                return Response(context, status=status.HTTP_200_OK)

            context = {'status': 0,'message':allreview_error_message['message']}
            return Response(context, status=status.HTTP_200_OK)

        except Exception as e:
            logger.error('ShowMagazineReadStatusInfoAPIView:error => ' + str(e))
            context = {'status': 0, 'message': Exp_MESSAGE['message']}
            return Response(context, status=status.HTTP_400_BAD_REQUEST)


# page not found
from django.shortcuts import render


def error_404(request,exception):
    return render(request, 'web/404.html', status=404)
