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 django.db.models.functions import ExtractYear
from magazineapp.models import*
from .serializers import*
from base.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 .paginations import AshishStandardResultsSetPagination
# 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().order_by('category_name')
            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):
        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': str}
            return Response(context, status=status.HTTP_400_BAD_REQUEST)

#promotional magazine
class PromotionalMagazineAPIView(generics.GenericAPIView):
    serializer_class = MagazineInfoSerializer
    # pagination_class = AshishStandardResultsSetPagination
    # permission_classes = (permissions.IsAuthenticated,)
    def get(self, request,id=None):
        try:   
            # users=MagazineInfo.objects.all()
            current_date = datetime.datetime.now() - datetime.timedelta(days=1)
            users=MagazineInfo.objects.filter((Q(published_date__date__lte=current_date.date())|Q(published_date=None)),is_aproved=True,is_active=True, is_promoted=True).all()
            print("++++++++++++Model Read")
            serializer = self.serializer_class(users,many=True)
            print("++++++++++++Serializer Read")
            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 })
                # print(mangine.query,'=======11111')
                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
                # print(magazine_category_id,'==id')
                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(mangine,'==11111111')
                # print(mangine.query,'=======11111')
                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)

# #search api ListAPIView
# 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)

## GenericAPIView search api
# class Search123APIView(generics.GenericAPIView):
#     serializer_class = MagazinebySystemSerializer
   
#     def get(self,request,format=None):
#         search = self.request.query_params.get('search',None)
#         try:
#             user = MagazineInfo.objects.filter(Q(name__icontains=search)|Q(name__icontains=search))
#             if user:
#                 serializer = self.serializer_class(user,many=True)
#                 context = {'status': 1,'message':'Magazine record search success.','data':serializer.data}
#                 return Response(context, status=status.HTTP_200_OK)
#             context = {'status': 0,'message':'please enter correct search data.'}
#             return Response(context, status=status.HTTP_200_OK)
            
#         except Exception as e:
#             context = {'status': 0, 'message': Exp_MESSAGE['message'],'error':str(e)}
#             return Response(context, status=status.HTTP_400_BAD_REQUEST)

# Code By ashish###########################################################################
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 not Magazineobj:
                context = {'status': 0,'message':'Record is not available.'}
                return Response(context, status=status.HTTP_200_OK)

            if Magazineobj and user_id:
                current_date = datetime.datetime.now() #- datetime.timedelta(days=1)
                magazinedata=MagazineInfo.objects.filter((Q(published_date__date__lte=current_date)|Q(published_date=None)),id=magazine_id,is_aproved=True,is_active=True).last()
                # magazinedata=MagazineInfo.objects.filter(id=magazine_id,is_aproved=True,is_active=True).last()
                    
                if not magazinedata:
                    context = {'status': 0,'message':'Record not found!'}
                    return Response(context, status=status.HTTP_200_OK)

                serializers = magazineSerializer(magazinedata,many=False,context = {"user":user_id,"magazine_id":magazine_id})
                # read_count = MagazineReadStatus.objects.filter(magazine = obj.id)
                magazinedata=MagazineInfo.objects.filter(id=magazine_id).update(reads=serializers.data.get('reads'))
                
                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)
            userobj = User.objects.filter(id=user_id).first()
            if not userobj:
                context = {'status': 0,'message':'User 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 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)
            page_number = request.data.get('page_number',None)
            data=request.data
            data['magazines']=data['magazines_id']
            data['users']=data['users_id']
            # data['page_number']=data['page_number'] if data['page_number'] else 0
            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'],page_number=page_number).last()
                bookmark=MagazineBookmark.objects.filter(users=usersdata.id,magazines=data['magazines']).last()
                
                if page_number == None:
                    bookmarkobj=MagazineBookmark.objects.filter(users=usersdata.id,magazines=data['magazines'],page_number =None).exists()
                    if not bookmarkobj:
                        serializer=MagazineBookmarkSerializer(data=data)
                        if serializer.is_valid():
                            serializer.save()
                            MagazineBookmark.objects.filter(users=usersdata.id,magazines=data['magazines'],page_number = None).update(bookmark_status =is_bookmark)
                            context = {'status': 1,'message': 'magzine bookmarked successfully'}
                            return Response(context, status=status.HTTP_200_OK)
                    MagazineBookmark.objects.filter(users=usersdata.id,magazines=data['magazines'],page_number= None).update(bookmark_status =is_bookmark)
                    context = {'status': 1,'message': 'magzine bookmarked successfully'}
                    return Response(context, status=status.HTTP_200_OK)

                if not bookmarkobj:
                    serializer=MagazineBookmarkSerializer(data=data)
                    if serializer.is_valid():
                        serializer.save()   
                        MagazineBookmark.objects.filter(users=usersdata.id,magazines=data['magazines'],page_number__isnull = False).update(bookmark_status =is_bookmark)                
                        context = {'status': 1,'message': bookmark_enter_message['message'],'data':serializer.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:
                    serializer=MagazineBookmarkSerializer(bookmarkobj)
                    context = {'status': 1,'message': 'User is already bookmark.','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'],page_number=page_number).last()
                
                if page_number == None:
                    MagazineBookmark.objects.filter(users=usersdata.id,magazines=data['magazines'],page_number=None).update(bookmark_status =is_bookmark)
                    context = {'status': 1,'message': 'magzine unbookmarked successfully'}
                    return Response(context, status=status.HTTP_200_OK)

                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)

# ###########################################################################################
# # server 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'] if data['page_number'] else 0
#             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'],page_number=data['page_number']).last()
#                 bookmark=MagazineBookmark.objects.filter(users=usersdata.id,magazines=data['magazines']).last()
#                 if not bookmarkobj:
#                     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':serializer.errors}
#                         return Response(context, status=status.HTTP_200_OK)
#                 else:
#                     serializer=MagazineBookmarkSerializer(bookmarkobj)
#                     context = {'status': 1,'message': 'User is already bookmark.','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'],page_number=data['page_number']).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
    # serializer_class = LBookmarkListSerializer
    # permission_classes = (permissions.IsAuthenticated,)
 
    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 user_id:
                context = {'status': 1,'message':'please enter user id'}
                return Response(context, status=status.HTTP_200_OK)
            if not magazine_id:
                context = {'status': 1,'message':'please enter magazine id'}
                return Response(context, status=status.HTTP_200_OK)

            userobj = User.objects.filter(id=user_id).first()
            magazineobj = MagazineInfo.objects.filter(id=magazine_id).first()
            if not userobj:
                context = {'status': 0,'message':'Please enter valid user id'}
                return Response(context, status=status.HTTP_200_OK) 
            if not magazineobj:
                context = {'status': 0,'message':'Please enter valid magazine id'}
                return Response(context, status=status.HTTP_200_OK)
            if userobj and magazineobj:
                # orderobj = MagazineBookmark.objects.filter(users=userobj.id,magazines=magazineobj.id).values_list('page_number',flat=True).distinct('page_number')
                orderobj = MagazineBookmark.objects.filter(users=userobj.id,magazines=magazineobj.id).values_list('page_number',flat=True).order_by('page_number').exclude(page_number__isnull=True)
                orderobj =  set(orderobj) if orderobj else []
                # serializers = self.serializer_class(orderobj,many=True,context={'user_id':user_id,'magazine_id':magazine_id})
                dict = {'pages':orderobj}
                context = {'status': 1,'message':Bookmark_list_message['message'],'data':dict}
                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:
                        print(serializer.errors,"<================Error Favorite!")
                        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)
                #############
                bookmark_id_li = MagazineBookmark.objects.filter(users=userid,page_number=None,bookmark_status=True).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,status="success")
                print(purchaseobj,'====purchase==')
                # serializer = MagazinePurchaseInfoSerializer(purchaseobj,many=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,status="success",is_buyed=True).values_list('magazineInfos',flat=True)
                bookmarkobj=MagazineBookmark.objects.filter(users=userid,page_number=None,bookmark_status=True).values_list('magazines',flat=True)
                favouriteobj=MagazineFavorite.objects.filter(users=userid).values_list('magazines',flat=True)

                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}
                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)


# #old test magazine search 
# class MagazineSearchAPIView(generics.ListAPIView):
#     # queryset = MagazineInfo.objects.all()
#     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')
#     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:]
#                 # querset = MagazinePurchaseInfo.objects.all()
#                 # magin_list = []
#                 # dataset = querset.values_list('magazineInfos').annotate(truck_count=Count('magazineInfos')).order_by('-truck_count')
#                 # if dataset:
#                 #     for row,key in dataset:
#                 #         magin_list.append(row)
#                 #         # print(row, '>>>>>>>>>>>',key)

#                 # querset = querset.annotate(Sum('magazineInfos')).order_by('magazineInfos').values_list('magazineInfos', flat=True)
#                 # querset = querset.latest('count')
#                 # print(dataset, '<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<')
#                 # breakpoint()
                
#                 ######################
#                 purchase_info = MagazinePurchaseInfo.objects.filter(is_buyed=True,status="success").all()

#                 print(purchase_info,'=======data==')
#                 querset = MagazinePurchaseInfo.objects.all()
#                 dataset = querset.values_list('magazineInfos').annotate(truck_count=Count('magazineInfos')).order_by('-truck_count')
#                 purchase_info = MagazinePurchaseInfo.objects.filter(is_buyed=True,status="success").all()[:10:]
              
#                 serializer = MagazinePurchaseInfoSerializer(purchase_info,many=True).data
#                 ######################

#                 # purchase_info = MagazinePurchaseInfo.objects.filter(magazineInfos__in=magin_list).all()
#                 # serializer = PuchaseSearchMagazineDetailSerializer(purchase_info,many=True).data


#                 # querset = MagazinePurchaseInfo.objects.filter(is_buyed=True,status="success").all()
#                 # magin_list = []
#                 # dataset = querset.values_list('magazineInfos').annotate(truck_count=Count('magazineInfos')).order_by('-truck_count')
#                 # # if dataset:
#                 # #     for row,key in dataset:
#                 # #         magin_list.append(row)
#                 # querset = querset.annotate(Sum('magazineInfos')).order_by('magazineInfos').values_list('magazineInfos', flat=True)
#                 # # querset = querset.latest('count')
#                 # magazineobj = MagazineInfo.objects.filter(id__in=querset)
#                 # serializer = PuchaseSearchMagazineDetailSerializer(magazineobj,many=True)
                
#                 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)



##server magazine search 
class MagazineSearchAPIView(generics.ListAPIView):
    queryset = MagMapAuthor.objects.filter(magazine__is_aproved=True,magazine__is_active=True).all()
    serializer_class = MagMapAuthorSerializer
    filter_backends = [filters.SearchFilter]
    search_fields = ['magazine_id__name','author_id__author_name','magazine_id__system_category__category_name','magazine_id__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:
                    print('===1111')
                    SearchMagazineinfo.objects.filter(title__icontains=search).update(count=F("count") + 1)
                    response = super().list(request, *args, **kwargs)
                    ########################
                    # for result in response.data:
                    #     name = list(result.strings().sort())[0][0:-1]
                    # print(((response.data)[0][0:-1]),'=======11111111123456-0987654====set(response.data) data')
                    ##############################
                    response.data = {'status': 1, 'message': search_message['message'],'data':(response.data)}
                    return response
                else:
                    print('=====22222')
                    searchobj=MagMapAuthor.objects.filter(Q(magazine_id__name__icontains=search)|Q(author_id__author_name__icontains=search)|Q(magazine_id__system_category__category_name__icontains=search)|Q(magazine_id__magazine_category__category_name__icontains=search)).last()
                    if searchobj:
                        print('=====33333')
                        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
                    print('=======44444')
                    response = super().list(request, *args, **kwargs)
                    response.data = {'status': 1, 'message': search_message['message'],'data': response.data}
                    return response
            else:
                print('=============5555555')
                search_info = SearchMagazineinfo.objects.all().values().order_by('-count')[:5:]

                querset = MagazinePurchaseInfo.objects.filter(is_buyed=True,status="success").all()
                magin_list = []
                dataset = querset.values_list('magazineInfos').annotate(truck_count=Count('magazineInfos')).order_by('-truck_count')
                if dataset:
                    for row,key in dataset:
                        magin_list.append(row)
                querset = querset.annotate(Sum('magazineInfos')).order_by('magazineInfos').values_list('magazineInfos', flat=True)
                # querset = querset.latest('count')
                magazineobj = MagazineInfo.objects.filter(id__in=querset,is_aproved=True,is_active=True)[:10:]
                serializer = PuchaseSearchMagazineDetailSerializer(magazineobj,many=True)

                dicts={'search_data':search_info,'puchase_data':serializer.data}
                response = super().list(request, *args, **kwargs)
                response.data = {'status': 1, 'message': search_message['message'],'data': dicts}
                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 CODE FOR COUNT
# class MagazineSearchAPIView(generics.ListAPIView):
#     # queryset = MagMapAuthor.objects.filter(magazine__is_aproved=True,magazine__is_active=True).all()
#     distinct = MagMapAuthor.objects.values('magazine_id').annotate(name_count=Count('magazine_id')).filter(name_count=1)
#     queryset = MagMapAuthor.objects.filter(magazine__is_aproved=True,magazine__is_active=True,magazine_id__in=[item['magazine_id'] for item in distinct]).all()
#     serializer_class = MagMapAuthorSerializer
#     filter_backends = [filters.SearchFilter]
#     search_fields = ['magazine_id__name','author_id__author_name']
#     ######################
#     def get_queryset(self):
#         # mag_map_details= MagMapAuthor.objects.filter(magazine__is_aproved=True,magazine__is_active=True).values_list('magazine__id',flat=True)
#         # mag_map_details= MagMapAuthor.objects.filter(magazine__is_aproved=True,magazine__is_active=True)
#         # mag_map_details=list(set(mag_map_details))

#         search = self.request.query_params.get('search', None)
#         if search:
#             search_info = SearchMagazineinfo.objects.filter(title__icontains=search).last()
#             if search_info:
#                 print('===1111')
#                 SearchMagazineinfo.objects.filter(title__icontains=search).update(count=F("count") + 1)
#                 # a= MagMapAuthor.objects.filter(magazine_id__in = mag_map_details).last()
#                 # searchobj=MagMapAuthor.objects.filter(Q(magazine__name__icontains=search)|Q(author__author_name__icontains=search),magazine__is_aproved=True,magazine__is_active=True).order_by('id').distinct()
#                 # print(searchobj,'====searchobj')
#                 # a=MagMapAuthor.objects.filter(id=searchobj.id)
#                 distinct = MagMapAuthor.objects.values('magazine_id').annotate(name_count=Count('magazine_id')).filter(name_count=1)
#                 queryset = MagMapAuthor.objects.filter(magazine__is_aproved=True,magazine__is_active=True,magazine_id__in=[item['magazine_id'] for item in distinct]).all()
#                 serializer_class = self.serializer_class(queryset, many = True)

#                 dicts={'count':len(serializer_class.data),'next':None,'previous':None,'results': serializer_class.data}
#                 return Response({'status': 1, 'message': search_message['message'],'data': dicts})
#             else:
#                 print('=====22222')
#                 searchobj=MagMapAuthor.objects.filter(Q(magazine__name__icontains=search)|Q(author__author_name__icontains=search),magazine__is_aproved=True,magazine__is_active=True).last()
#                 if searchobj:
#                     print('=====33333')
#                     searchid=SearchMagazineinfo.objects.create(title=search)
#                     SearchMagazineinfo.objects.filter(id = searchid.id).update(magazineInfos = searchobj.id)
#                     # return mag_map_details
#                     # return Response({'status': 1, 'message': search_message['message'],'data': mag_map_details})
#                     # a= MagMapAuthor.objects.filter(magazine_id__in = mag_map_details).last()
#                     # a=MagMapAuthor.objects.filter(id=a.id)
#                     serializer_class = self.serializer_class(searchobj, many = True)
#                     dicts={'count':len(serializer_class.data),'next':None,'previous':None,'results': serializer_class.data}
#                     return Response({'status': 1, 'message': search_message['message'],'data': dicts})
#                 print('=======44444')

#         else:
#             print('=============5555555')
#             search_info = SearchMagazineinfo.objects.all().values().order_by('-count')[:5:]

#             querset = MagazinePurchaseInfo.objects.filter(is_buyed=True,status="success").all()
#             magin_list = []
#             dataset = querset.values_list('magazineInfos').annotate(truck_count=Count('magazineInfos')).order_by('-truck_count')
#             if dataset:
#                 for row,key in dataset:
#                     magin_list.append(row)
#             querset = querset.annotate(Sum('magazineInfos')).order_by('magazineInfos').values_list('magazineInfos', flat=True)
#             # querset = querset.latest('count')
#             magazineobj = MagazineInfo.objects.filter(id__in=querset,is_aproved=True,is_active=True)[:10:]
#             serializer = PuchaseSearchMagazineDetailSerializer(magazineobj,many=True).data
#             dicts={'search_data':search_info,'puchase_data':serializer.data}
#             # return Response({'status': 1, 'message': search_message['message'],'data': dicts})
#             return dicts

#         # 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)
# # ########################ends

# 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)


    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')
                if lastid:
                    lastid = lastid.id
                else:
                    lastid = '001'
            except MagazinePurchaseInfo.DoesNotExist:
                lastid = '001'
            code = f"MAG{request.data['magazineInfos']}{lastid}"
            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()

            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)
                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']if request.data['offer_id'] else 0)|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(request.data['buy_price'])*(float(couponobj.discount)/100)
                    # offerprice=float(request.data['buy_price'])-float(offerobj)
                    request.data['offer_discount'] = couponobj.discount
                    ##########
                    offerprice1=couponobj.max_discount
                    ##################

                    offerprice1=couponobj.max_discount
                    if couponobj.max_discount=="":
                        percentage=float(request.data['buy_price'])*(float(couponobj.discount)/100)
                        offer_dis=float(request.data['buy_price'])-float(percentage)
                       
                    else: 
                        if offerprice1:
                            if offerobj > float(offerprice1):
                                offer_dis=float(request.data['buy_price'])-float(offerprice1)
                            else:
                                offer_dis=(float(request.data['buy_price']))-float(offerobj)
                        else:
                            offer_dis=(float(request.data['buy_price']))-float(offerobj)
  
                    request.data['offer_discount_amount'] = (offerobj)
                    request.data['offer_max_amount'] = (offerprice1)
                    request.data['offer_price'] = round(offer_dis,2)
                    request.data['is_offered'] = True

                pstatus = (request.data.get('status')).lower()
                buyobj = MagazinePurchaseInfo.objects.filter(users=request.data['user_id'],magazineInfos=request.data['magazineInfos'],is_buyed=True,status='success').last()
                if buyobj:
                    # MagazinePurchaseInfo.objects.filter(users=request.data['user_id'],magazineInfos=request.data['magazineInfos'],is_buyed=True,status='success').update(count=F("count") + 1)
                    context = {'status': 0,'message':'User has been already taken buy.'}
                    return Response(context, status=status.HTTP_200_OK)
                if pstatus == "success":
                    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 purchased {magazineobj.name} successfully.'
                        send_push_notification(user_id, title, msg)
                        
                        # NotificationSerializer save
                        dicts = {'user':userdetails.id,'message':msg}
                        print(dicts,'dicts data===')
                        serializer = NotificationSerializer(data=dicts)
                        if serializer.is_valid():
                            serializer.save()
                        else:
                            context = {'status': 0,'message':serializer.errors}
                            return Response(context, status=status.HTTP_200_OK)

                        print(magazineobj.users.username,'============pub@@@@@@@@@@@@@')
                        record_data = {'username':userdetails.username,'message':msg, 'name':userdetails.first_name,'publisher':magazineobj.users.username}
                        BuyMailToUserThread(record_data).start()

                        context = {'status': 1,'message':'Magazine purchased successfully','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)
                if pstatus == "fail":

                    ####################################
                    otp = ''.join(random.choices(string.digits, k = 2))
                    request.data['transaction_id']=f"MAG{request.data['magazineInfos']}{otp}{lastid}"
                    ##############################
                    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}, Transaction cancelled {magazineobj.name}.'
                        send_push_notification(user_id, title, msg)

                        # NotificationSerializer save
                        dicts = {'user':userdetails.id,'message':msg}
                        print(dicts,'dicts data===')
                        serializer = NotificationSerializer(data=dicts)
                        if serializer.is_valid():
                            serializer.save()
                        else:
                            context = {'status': 0,'message':serializer.errors}
                            return Response(context, status=status.HTTP_200_OK)

                        record_data = {'username':userdetails.username,'message':msg, 'name':userdetails.first_name,'publisher':magazineobj.users.username}
                        FailMailToUserThread(record_data).start()

                        context = {'status': 1,'message':'Payment canceled.','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:
                    context = {'status': 0,'message':'Please enter purchase status.'}
                    return Response(context, status=status.HTTP_200_OK)
            
            elif request.data['is_rented'] == True:
                rent_history = MagazinePurchaseInfo.objects.filter(users_id=request.data['user_id'], is_rented=True).last()
                print(rent_history,"======================rent_history")
                current_date = datetime.datetime.now() 
                if rent_history:
                    if rent_history.rent_date:
                        if rent_history.rent_date <= current_date <= rent_history.rent_expiry_date and rent_history.status == "success":
                            context = {'status': 0,'message':'Rent exist on this user id.'}
                            return Response(context, status=status.HTTP_200_OK)

                pstatus = (request.data.get('status')).lower()
                rentobj = UserRent.objects.filter(rent_status=True).last()
                request.data['magazineInfos']=request.data.get('magazine_id')
                rentday = int(rentobj.validity) * 28
                rentprice=request.data.get('price')
                print(rentday,"RentDay+++++++++")
                request.data['rent_date']=datetime.datetime.now()
                request.data['rent_expiry_date']=datetime.datetime.now() + datetime.timedelta(days=rentday)
                # breakpoint()
                request.data['rent_price']= rentprice
               
                if pstatus == "success":
                    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 rented {magazineobj.name} successfully.'
                        send_push_notification(user_id, title, msg)

                        # NotificationSerializer save
                        dicts = {'user':userdetails.id,'message':msg}
                        serializer = NotificationSerializer(data=dicts)
                        if serializer.is_valid():
                            serializer.save()
                        else:
                            context = {'status': 0,'message':serializer.errors}
                            return Response(context, status=status.HTTP_200_OK)

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

                        context = {'status': 1,'message':'Magazine rented successfully','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)

                if pstatus == "fail":
                    ####################################
                    otp = ''.join(random.choices(string.digits, k = 2))
                    request.data['transaction_id']=f"MAG{request.data['magazineInfos']}{otp}{lastid}"
                    ##############################
                    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}, Transaction cancelled {magazineobj.name}.'
                        send_push_notification(user_id, title, msg)

                        # NotificationSerializer save
                        dicts = {'user':userdetails.id,'message':msg}
                        print(dicts,'dicts data===')
                        serializer = NotificationSerializer(data=dicts)
                        if serializer.is_valid():
                            serializer.save()
                        else:
                            context = {'status': 0,'message':serializer.errors}
                            return Response(context, status=status.HTTP_200_OK)

                        record_data = {'username':userdetails.username,'message':msg, 'name':userdetails.first_name,'publisher':magazineobj.users.username}
                        FailMailToUserThread(record_data).start()

                        context = {'status': 1,'message':'Payment canceled.','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:
                    context = {'status': 0,'message':'Please enter purchase status.'}
                    return Response(context, status=status.HTTP_200_OK)

            elif request.data['is_subscription'] == True:
                request.data['rent_date']=datetime.datetime.now()
                request.data['magazineInfos']=1
                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
                pstatus = (request.data.get('status')).lower()
                substime= MagazinePurchaseInfo.objects.filter(users=request.data['users'],is_subscription=True,subscription_user_status=True,status='success').last()
                if substime:
                    context = {'status': 1,'message':'User has been already taken subscription',}
                    return Response(context, status=status.HTTP_200_OK)
                if pstatus == "success":
                    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()
                        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 subscripted magazines successfully.'
                        send_push_notification(user_id, title, msg)

                        # NotificationSerializer save
                        dicts = {'user':userdetails.id,'message':msg}
                        serializer = NotificationSerializer(data=dicts)
                        if serializer.is_valid():
                            serializer.save()
                        else:
                            context = {'status': 0,'message':serializer.errors}
                            return Response(context, status=status.HTTP_200_OK)

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

                        context = {'status': 1,'message':'Magazine subscription purchased successfully','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)
                if pstatus == "fail":
                    ####################################
                    otp = ''.join(random.choices(string.digits, k = 2))
                    request.data['transaction_id']=f"MAG{request.data['magazineInfos']}{otp}{lastid}"
                    ##############################
                    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()
                        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}, Transaction cancelled.'
                        send_push_notification(user_id, title, msg)

                        # NotificationSerializer save
                        dicts = {'user':userdetails.id,'message':msg}
                        serializer = NotificationSerializer(data=dicts)
                        if serializer.is_valid():
                            serializer.save()
                        else:
                            context = {'status': 0,'message':serializer.errors}
                            return Response(context, status=status.HTTP_200_OK)

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

                        context = {'status': 1,'message':'Payment canceled.','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:
                    context = {'status': 0,'message':'Please enter purchase status.'}
                    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)
                user = User.objects.filter(id=request.data['users']).last()
                all_aaddress = str(user.address)
                all_aaddress=f"{user.address},{user.address_line_2},{user.state},{user.zipcode},{user.city},{user.country_name}"
                # all_aaddress=f"{user.address},{user.address_line_2},{user.state},{user.zipcode},{user.country_name}"
                # request.data['delivery_location'] = user.address if user.address else ""
                request.data['delivery_location'] = all_aaddress
                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()
                    print('====1',offer_code)
                    couponobj =  MagazineOfferinfo.objects.filter(Q(id=request.data['offer_id']if request.data['offer_id'] else 0)|Q(code__iexact=offer_code if offer_code else "")).last()
                    print('==222',couponobj)
                    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)
                    print('===33')
                    request.data['magazineOffer']=couponobj.id
                    offerobj=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
                    offerprice1=couponobj.max_discount
                    ##################

                    offerprice1=couponobj.max_discount
                    if couponobj.max_discount=="" or couponobj.max_discount=="null" or couponobj.max_discount==None:
                        percentage=float(request.data['hard_copy_price'])*(float(couponobj.discount)/100)
                        offer_dis=float(request.data['hard_copy_price'])-float(percentage)
                       
                    else:
                        if offerprice1:
                            if offerobj > float(offerprice1):
                                offer_dis=(float(request.data['hard_copy_price'])-float(offerprice1))
                            else:
                                offer_dis=(float(request.data['hard_copy_price']))-float(offerobj)
                        else:
                            offer_dis=(float(request.data['hard_copy_price']))-float(offerobj)

    
                    request.data['offer_discount_amount'] = (offerobj)
                    request.data['offer_max_amount'] = (offerprice1)
                    request.data['offer_price'] = round(offer_dis,2)
                    request.data['is_offered'] = True
                pstatus = (request.data.get('status')).lower()
                if pstatus == "success":
                    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 purchased {magazineobj.name} successfully.'
                        send_push_notification(user_id, title, msg)

                        # NotificationSerializer save
                        dicts = {'user':userdetails.id,'message':msg}
                        serializer = NotificationSerializer(data=dicts)
                        if serializer.is_valid():
                            serializer.save()
                        else:
                            context = {'status': 0,'message':serializer.errors}
                            return Response(context, status=status.HTTP_200_OK)

                        # record_data = {'username':userdetails.username,'message':msg, 'name':userdetails.first_name}
                        record_data = {'username':userdetails.username,'message':msg, 'name':userdetails.first_name,'publisher':magazineobj.users.username}
                        HardcopyMailToUserThread(record_data).start()

                        context = {'status': 1,'message':'Magazine hard copy purchased successfully','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)
                if pstatus == "fail":
                    ####################################
                    otp = ''.join(random.choices(string.digits, k = 2))
                    request.data['transaction_id']=f"MAG{request.data['magazineInfos']}{otp}{lastid}"
                    ##############################
                    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}, Transaction canceled {magazineobj.name}.'
                        send_push_notification(user_id, title, msg)

                        # NotificationSerializer save
                        dicts = {'user':userdetails.id,'message':msg}
                        serializer = NotificationSerializer(data=dicts)
                        if serializer.is_valid():
                            serializer.save()
                        else:
                            context = {'status': 0,'message':serializer.errors}
                            return Response(context, status=status.HTTP_200_OK)

                        # record_data = {'username':userdetails.username,'message':msg, 'name':userdetails.first_name}
                        record_data = {'username':userdetails.username,'message':msg, 'name':userdetails.first_name,'publisher':magazineobj.users.username}
                        FailHardcopyMailToUserThread(record_data).start()

                        context = {'status': 1,'message':'Payment canceled.','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:
                    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:

                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,offer_status=True,end_date__gte=current_date)
                userobj1 = MagazineOfferinfo.objects.filter(for_users__icontains="All",offer_status=True,end_date__gte=current_date)
                userobj2 = MagazineOfferinfo.objects.filter(id__in=useroffer,offer_status=True,for_users__icontains="Perticular",end_date__gte=current_date)
                offerobj = list((set(userobj)).union(set(userobj1)).union(userobj2))

                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)

            userobj = MagazineOfferinfo.objects.filter(for_users__icontains="All",offer_status=True,start_date__gte=current_date,end_date__lte=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)



# 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)
            offerprice1 = 0  # surya
            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 valid promo 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)

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

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

                    # offerprice=round(offerpr, 2)
                    if userobj.max_discount:
                        # print(userobj.max_discount,"<=============== Max Discount")
                        offerprice1=float(userobj.max_discount)
                        if percentage > offerprice1:
                            deduct_price=offerprice1
                            # print(offerprice1,"==========>offerprice1") 
                            offer_dis=(float(amount)-float(offerprice1))
                            # print(offer_dis,"==========>dicsofferq1")
                        else:
                            deduct_price=percentage
                            offer_dis=(float(amount)-float(percentage))
                            # print(offer_dis,"==========>dicsoffer")  
                    else:
                        deduct_price=percentage
                        offer_dis=(float(amount)-float(percentage))
                        # print(offer_dis,"==========>dicsoffer") 

                    offer = MagazineOfferinfo.objects.filter(Q(id__iexact=coupon_id)|Q(code__iexact=coupon_id)).last()
                    dic={'id':offer.id,'real_price':amount,'deduct_price':round(deduct_price,2),'offer_price':round(offer_dis,2),'discount_price':round(percentage,2),'code':offer.code,'discount':offer.discount,'max_discount_price':round(offerprice1,2),'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_price':round(offerprice1,2),'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)

            #################
            # userlist = User.objects.filter(id=user_id).first()
            # sortnameobj = Country.objects.filter(sortname__iexact=sort_name).first()
            # if not userlist:
            #     context = {'status': 0,'message':'Please enter valid user id'}
            #     return Response(context, status=status.HTTP_200_OK)
            # if not sortnameobj:
            #     context = {'status': 0,'message':'Please enter valid sorname'}
            #     return Response(context, status=status.HTTP_200_OK)
            ###########

            if user_id and sort_name:
                try:
                    user = User.objects.filter(id=int(user_id)).last()
                    # countryonj = Country.objects.filter(id=user.country.id).last()
                    countryonj = Country.objects.filter(Q(sortname=sort_name)|Q(id=user.country.id)).last()
                    # subscriptionobj1 = SubscriptionType.objects.filter(country=user.country.id).values_list('id', flat=True)
                    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,status="success").all()
                except Exception:
                    mysubl = MagazinePurchaseInfo.objects.none()

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

                subscriptionobj = SubscriptionType.objects.filter(country=countryonj.id,subscription_status=True).all().order_by('per_month_price')
                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)


# # test 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)
#             current_date=datetime.datetime.now()
#             buydata = MagazinePurchaseInfo.objects.filter(users=user_id,is_buyed=True,status="success").all().order_by('-updated_on')
#             rentdata = MagazinePurchaseInfo.objects.filter(users=user_id,is_rented=True,status="success",rent_expiry_date__gte=current_date).all().order_by('-updated_on')
#             harddata = MagazinePurchaseInfo.objects.filter(users=user_id,is_hard_copy=True,status="success").all().order_by('-updated_on')
#             # MagazinePurchaseInfo.objects.filter(id__in=)
#             userdata = list((set(buydata)).union(set(rentdata)).union(set(harddata)))
#             serializers = MGAOrderHistorySerializer(userdata,many=True,context={'user_id':user_id})
#             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 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)
            current_date=datetime.datetime.now()
            buydata = MagazinePurchaseInfo.objects.filter(users=user_id,is_buyed=True).all().values_list('id',flat=True)
            rentdata = MagazinePurchaseInfo.objects.filter(users=user_id,is_rented=True,rent_expiry_date__gte=current_date).all().values_list('id',flat=True)
            harddata = MagazinePurchaseInfo.objects.filter(users=user_id,is_hard_copy=True).all().values_list('id',flat=True)
            userdata = list((set(buydata)).union(set(rentdata)).union(set(harddata)))
            userdata = MagazinePurchaseInfo.objects.filter(id__in=userdata).order_by('-updated_on')
            serializers = MGAOrderHistorySerializer(userdata,many=True,context={'user_id':user_id})
            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 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)

            # purchasedata = MagazinePurchaseInfo.objects.filter(id=order_id,users=user_id).all().order_by('-id')
            purchasedata = MagazinePurchaseInfo.objects.filter(id=order_id,users=user_id).all().order_by('-id')
            if purchasedata:
                serializers = MagazineOrderDetailSerializer(purchasedata,many=True,context={'user_id':user_id,'order_id':order_id} )
                context = {'status': 1,'message': 'magazine order detail records found successfully','data':serializers.data}
                return Response(context, status=status.HTTP_200_OK)
            # elif subdata:
            #     serializers = MagazineOrderDetailSerializer(subdata,many=True)
            #     context = {'status': 1,'message': 'magazine order detail records found successfully','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) 

        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)

# 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()
                if not orderobj:
                    context = {'status': 0,'message':'Magazine review record found success','data':[]}
                    return Response(context, status=status.HTTP_200_OK)
                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)
            data['ratting']=data.get('ratting') if data.get('ratting') else 1
            
            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)
            # magazine_id=None

            # 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().order_by('-updated_on')
                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().order_by('-updated_on')
                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 user_id:
                magazine_id=None
                orderobj = magazineReviewInfo.objects.filter(users=user_id).all().order_by('-updated_on')
                serializers = MagazineReviewInfoHistorySerializer(orderobj,many=True,context={"user_id":user_id})
                context = {'status': 1,'message':allreview_error_message['message'],'data':serializers.data}
                return Response(context, status=status.HTTP_200_OK)
            else:
                context = {'status': 0,'message':'Rocords are not available'}
                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)

        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)

# get notification list Api
class ListNotificationAPIView(generics.GenericAPIView):
    serializer_class = ListNotificationSerializer

    def get(self, request,id=None):
        try:
            data = []
            date_key = {}
            user_id = self.request.query_params.get('user_id', None)
            if user_id:
                userobj = User.objects.filter(id=user_id)
                if not userobj:
                    context = {'status': 0,'message':'Please enter correct user id.'}
                    return Response(context, status=status.HTTP_200_OK)
                last_seven_date = datetime.datetime.now().date() - datetime.timedelta(days=7)

                Notification.objects.filter(user=user_id)
                notification_orderobj = Notification.objects.filter(user=user_id,created_on__date__gte=last_seven_date).all().order_by('-created_on')
                orderobj = notification_orderobj.values_list('created_on__date',flat=True)
                print(orderobj,"=========")
                only_unique =  set(orderobj) if orderobj else []
                print(only_unique,"<<<<<<========")
                for i in only_unique:
                    print(i,"iiiii========")
                    objs = notification_orderobj.filter(created_on__date=i).values('id','message','created_on','updated_on','read')
                    date_key['date'] = str(i)
                    date_key['data'] = objs
                    print(date_key,"asdfg========")
                    data.append(date_key)
                    date_key = {}
                # print(data,"====================")
                
                # breakpoint()
                # orderobj1 = Notification.objects.filter(user=user_id).values_list('updated_on')

                # print(orderobj1,"================")
                
                    
                # serializers = self.serializer_class(orderobj,many=True)
                context = {'status': 1,'message':'User notification list found success','data':data}
                return Response(context, status=status.HTTP_200_OK)
            else:
                notification_orderobj = Notification.objects.filter(
                    read=False
                ).order_by('-created_on')
                print(notification_orderobj, "<< RAW QUERYSET")
                orderobj = notification_orderobj.values_list('created_on__date',flat=True)
                print(orderobj,"=========", notification_orderobj)
                only_unique =  set(orderobj) if orderobj else []
                print(only_unique,"<<<<<<========")
                for i in only_unique:
                    print(i,"iiiii========")
                    objs = notification_orderobj.filter(created_on__date=i).values('id','message','created_on','updated_on')
                    date_key['date'] = str(i)
                    date_key['data'] = objs
                    print(date_key,"asdfg========")
                    data.append(date_key)
                    date_key = {}
                
                context = {'status': 1,'message':'User notification list found success','data':data}
                return Response(context, status=status.HTTP_200_OK)

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

    def delete(self,request,id=None):
        try:
            user_id = self.request.query_params.get('user_id', None)
            # notification_id = self.request.query_params.get('notification_id', None)
            notification_id = self.request.query_params.get('notification_id') if self.request.query_params.get('notification_id') else 0

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

            userobj = User.objects.filter(id=user_id).first()
            notiobj = Notification.objects.filter(id=notification_id).first()

            if userobj is None:
                context = {'status': 0,'message':'Please enter valid user id.'}
                return Response(context, status=status.HTTP_200_OK)
            notificationobj = Notification.objects.filter(user=userobj.id,id=notification_id)

            usernotification = Notification.objects.filter(user=userobj.id)
            if notificationobj:
                print('user noti')
                notificationobj.delete()
                context = {'status': 1,'message':'User notification is delete success.',}
                return Response(context, status=status.HTTP_200_OK)
            elif usernotification:
                print('user ====')
                usernotification.delete()
                context = {'status': 1,'message':'User notification is delete success.',}
                return Response(context, status=status.HTTP_200_OK)
            else:
                context = {'status': 0,'message':'User notification is not delete.',}
                return Response(context, status=status.HTTP_200_OK)
            # if not notiobj:
            #     context = {'status': 0,'message':'Please enter correct notification id.'}
            #     return Response(context, status=status.HTTP_200_OK)

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

    def patch(self, request, id=None):
        try:
            notification_id = self.request.query_params.get('notification_id', None)
            if notification_id:
                notification = Notification.objects.filter(id=notification_id).first()
                if not notification:
                    context = {'status': 0, 'message': 'Notification not found.'}
                    return Response(context, status=status.HTTP_200_OK)

                notification.read = True
                notification.save()
                context = {'status': 1, 'message': 'Notification marked as read.'}
                return Response(context, status=status.HTTP_200_OK)
            # else:
            #     # Mark all user notifications as read
            #     Notification.objects.filter(user=userobj.id, read=False).update(read=True)
            #     context = {'status': 1, 'message': 'All notifications marked as read.'}
            #     return Response(context, status=status.HTTP_200_OK)

        except Exception as e:
            logger.error('ListNotificationAPIView:patch:error => ' + str(e))
            context = {'status': 0, 'message': 'Something went wrong while updating notification.'}
            return Response(context, status=status.HTTP_400_BAD_REQUEST)


# Send Grid through send mail using third party package.

# Get Blogs
class GetBlogs(generics.GenericAPIView):
    serializer_class = BlogDetailSerializer
    def get(self, request):
        try:
            blog_id = self.request.query_params.get('blog_id', None)
            if blog_id:
                blogs_data = Blogs.objects.filter((Q(is_deleted=False)|Q(is_deleted=None)),id=blog_id,is_active=True,is_aproved=True).last()
                if not blogs_data:
                    context = {'status': 0,'message':'Record is not available.'}
                    return Response(context, status=status.HTTP_200_OK)    
                serializers = self.serializer_class(blogs_data,many=False)
                context = {'status': 1,'message':'Blogs data found successfully','data':serializers.data}
                return Response(context, status=status.HTTP_200_OK)

            blogs_data = Blogs.objects.filter((Q(is_deleted=False)|Q(is_deleted=None)),is_active=True,is_aproved=True).all()
            serializers = self.serializer_class(blogs_data,many=True)
            context = {'status': 1,'message':'Blogs 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)


########
# Script To Add MagazineInfo Data to Magazine-Map-Author Table
# class AddData(generics.GenericAPIView):
#     def post(self, request):
#         magazine_data = MagazineInfo.objects.all()
#         magazine_in_mapauthor_table = MagMapAuthor.objects.all().values_list('magazine_id')
#         for magazine in magazine_data:
#             if magazine.id in magazine_in_mapauthor_table:
#                 pass
#             else:
#                 magazine_data = MagMapAuthor()
#                 magazine_data.magazine_id = magazine.id
#                 magazine_data.save()

#         context = {'status': 1,'message':'Data added successfully!'}
#         return Response(context, status=status.HTTP_200_OK)

#     def post(self, request):
#         magazine_in_mapauthor_table = MagMapAuthor.objects.all()
#         for magazine in magazine_data:
#             if magazine.id in magazine_in_mapauthor_table:
#                 pass
#             else:
#                 magazine_data = MagMapAuthor()
#                 magazine_data.magazine_id = magazine.id
#                 magazine_data.save()

#         context = {'status': 1,'message':'Data added successfully!'}
#         return Response(context, status=status.HTTP_200_OK)


### User address api
class UserAddressAPIViews(generics.GenericAPIView):
    serializer_class = UserAddressSerializer
    def get(self, request):
        try:
            user_id = self.request.query_params.get('user_id', None)
            if user_id:
                address_data = UserAddress.objects.filter(user=user_id).last()
                print(address_data)
                if not address_data:
                    context = {'status': 0,'message':'Record is not available.'}
                    return Response(context, status=status.HTTP_200_OK)    
                serializers = self.serializer_class(address_data,many=False)
                context = {'status': 1,'message':'User address data found successfully','data':serializers.data}
                return Response(context, status=status.HTTP_200_OK)
            context = {'status': 0,'message':'Record is not available.'}
            return Response(context, status=status.HTTP_200_OK)

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

    def post(self, request):
        try:

            data = request.data
            data['user'] = request.data.get('user_id', None)
            data['address1']=request.data.get('address1', None)
            data['address2']=request.data.get('address2', None)
            data['country']=request.data.get('country_id', None)
            addressobj = UserAddress.objects.filter(user=data['user'],country=data['country']).last()
            if addressobj:
                context = {'status': 0,'message':'User address record already available.'}
                return Response(context, status=status.HTTP_200_OK)
            serializers = PostUserAddressSerializer(data=data)
            if serializers.is_valid():
                serializers.save()
                context = {'status': 1,'message':'User address record create successfully','data':serializers.data}
                return Response(context, status=status.HTTP_200_OK)

            context = {'status': 0,'message':serializers.errors}
            return Response(context, status=status.HTTP_200_OK)

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

# import os
# import sys
# import datetime
# def del_older_files(req_path):
#   N=90
#   if not os.path.exists(req_path):
#     print("Please provide valid path")
#     sys.exit(1)
#   if os.path.isfile(req_path):
#     print("Please provide dictionary path")
#     sys.exit(2)
#   today=datetime.datetime.now()
#   for each_file in os.listdir(req_path):
#     each_file_path=os.path.join(req_path,each_file)
#     if os.path.isfile(each_file_path):
#       file_cre_date=datetime.datetime.fromtimestamp(os.path.getctime(each_file_path))
#       dif_days=(today-file_cre_date).days
#       if dif_days > N:
#         os.remove(each_file_path)
#         print(each_file_path,dif_days)
# req_path=input("Enter your path: ")
# del_older_files(req_path)

# /home/admin2/Desktop/magazine_project/magazine_project/magazine_web_admin/logs





from rest_framework.views import APIView
from datetime import timedelta

from django.utils.timezone import now
from rest_framework import status, permissions

class AdminNotificationListAPIView(APIView):
    # 👇 No authentication required
    permission_classes = []

    def get(self, request):
        try:
            user_id = request.query_params.get('user_id')
            if not user_id:
                return Response({
                    'status': 0,
                    'message': 'Missing user_id in request.'
                }, status=status.HTTP_400_BAD_REQUEST)

            user = User.objects.filter(id=user_id).first()
            if not user or user.roles_id != Role.ADMIN:
                return Response({
                    'status': 0,
                    'message': 'User not found or not authorized.'
                }, status=status.HTTP_403_FORBIDDEN)

            last_seven_days = now().date() - timedelta(days=7)
            notifications = Notification.objects.filter(
                user__isnull=True,  # 👈 Admin-visible only
                created_on__date__gte=last_seven_days
            ).order_by('-created_on')

            data = []
            unique_dates = notifications.values_list('created_on__date', flat=True).distinct()
            for date in unique_dates:
                grouped = notifications.filter(created_on__date=date).values('id', 'message', 'created_on', 'updated_on')
                data.append({
                    'date': str(date),
                    'data': grouped
                })

            return Response({
                'status': 1,
                'message': 'Admin notifications fetched successfully.',
                'data': data
            }, status=status.HTTP_200_OK)

        except Exception as e:
            logger.error(f'AdminNotificationListAPIView:error => {str(e)}')
            return Response({
                'status': 0,
                'message': 'Something went wrong while fetching admin notifications.'
            }, status=status.HTTP_500_INTERNAL_SERVER_ERROR)
