from django.shortcuts import render,redirect,get_object_or_404,HttpResponseRedirect
from .models import*
from django.views.generic import ListView, DetailView, UpdateView, CreateView,DeleteView, View, TemplateView
from django.urls import reverse_lazy
from django.http import HttpResponse,HttpResponseRedirect
from django.db.models import Q
import requests
from django.conf import settings
from django.contrib import messages
import json
from django.contrib.auth.decorators import login_required
from .filters import ListingFilter
# from .filters import function_choices
from .forms import *
from django.db import transaction
from .filters import ListingFilter
from .filters import ListingFilterMenu
from django.contrib.auth import authenticate, login, logout
from django.contrib.admin.views.decorators import staff_member_required
from django.contrib.auth.mixins import LoginRequiredMixin
from django.http import Http404

from django.core.mail import send_mail, BadHeaderError
from django.conf import settings
from getyourmenu.settings import DEFAULT_FROM_EMAIL
from django.core.mail import EmailMessage
from django.core import mail
from django.core.mail import EmailMultiAlternatives
from django.template.loader import render_to_string
from django.utils.html import strip_tags
from urllib.parse import urlencode

import os
from xml.sax.saxutils import escape

from django.http import HttpResponse
from django.urls import reverse, get_resolver, URLPattern, URLResolver

import certifi

# Create your views here.

class BlogSearchView(ListView):
    model = Post
    template_name = 'front/blog.html'
    context_object_name = 'posts'

    def get_queryset(self):
        query = self.request.GET.get('q')
        return Post.objects.filter(title__icontains=query).order_by('-publish')

# def Package_detail(request, slug):
#     social = SocialMedia.objects.all()
#     postpass = get_object_or_404(AddFunctionModel, slug=slug)
#     postpa = AddFunctionModel.objects.all()
#     photos = MenuByFunctionModel.objects.filter(slug=postpass)
    
#     return render(request, 'front/package-detail.html', {
#         'postpa':postpa,
#       'postpass':postpass,
#         'photos': photos,
#          'socials' : social,
       
        
#     })

####CHANGED DATE :: 13-July-2026#########
class Package_detail(ListView):
    model = MenuByFunctionModel
    template_name = 'front/package-detail.html'
    context_object_name = 'photos'

    def get(self, request, *args, **kwargs):
        name = request.GET.get('name', '').strip()
        email = request.GET.get('email', '').strip()
        phone = request.GET.get('phone', '').strip()
        venue = request.GET.get('venue', '').strip()
        date = request.GET.get('date') or None
        budget = request.GET.get('budget', '').strip()
        message = request.GET.get('message', '').strip()

        capacity_values = request.GET.getlist('capacity')

        package_capacity = (
            capacity_values[0]
            if len(capacity_values) > 0
            else ''
        )

        contact_capacity = (
            capacity_values[1]
            if len(capacity_values) > 1
            else package_capacity
        )

        if name and phone:
            ContactModel.objects.create(
                name=name,
                email=email,
                phone=phone,
                venue=venue,
                date=date,
                budget=budget,
                capacity=contact_capacity,
                message=message
            )
            html_content = render_to_string("front/email.html")
            text_content = strip_tags(html_content)
            newemail = "catering@ambria.in"
            email = EmailMultiAlternatives('Thank you for showing interest in GetYourMenu ', text_content , settings.DEFAULT_FROM_EMAIL, [newemail])
            email.attach_alternative(html_content,"text/html")
            email.send()
            messages.info(
                request,
                'Successfully Submitted!'
            )
            return redirect('Thanks-page')
           

        return super().get(request, *args, **kwargs)

    def get_queryset(self):
        queryset = self.model.objects.all()

        function_name = self.request.GET.get(
            'function_name',
            ''
        ).strip()

        capacity = self.request.GET.get(
            'capacity',
            ''
        ).strip()

        veg_nonveg = self.request.GET.get(
            'veg_nonveg',
            ''
        ).strip()

        price_per_plate = self.request.GET.get(
            'PricePerPlate',
            ''
        ).strip()

        if function_name:
            queryset = queryset.filter(
                alt_text__iexact=function_name
            )

        if capacity:
            queryset = queryset.filter(
                menu_pax__contains=capacity
            )

        if veg_nonveg:
            queryset = queryset.filter(
                veg_non_veg__iexact=veg_nonveg
            )

        if price_per_plate:
            queryset = queryset.filter(
                menu_price__contains=price_per_plate
            )

        return queryset




# def package_detail(request):
#     if request.method == 'POST':
#         name = request.POST['name']
#         email = request.POST['email']
#         phone = request.POST['phone']
#         venue = request.POST['venue']
#         message = request.POST['message']
#         capacity = request.POST['capacity']
 #       function = request.POST['function']
#         budget = request.POST['budget']
#         func = FunctionModel.objects.all()
#         date = request.POST['date']
#         clientKey = request.POST['g-recaptcha-response']
#         secretKey = "6Lcnwp8hAAAAAFNda3ZsfwMzDsVOsLU5yMBoZpa0"
#         captchaData = {
#             'secret': secretKey,
#             'response': clientKey,
#         }
#         r = requests.post("https://www.google.com/recaptcha/api/siteverify", data=captchaData)
#         response = json.loads(r.text)
#         verify = response['success']
        
#         user = ContactModel.objects.create(name=name, email=email, phone=phone, venue=venue, date=date, budget=budget, capacity=capacity, message=message)
#         user.save()
#         html_content = render_to_string("front/email.html")
#         text_content = strip_tags(html_content)
        
#         email = EmailMultiAlternatives('Thank you for showing interest in GetYourMenu ', text_content , settings.DEFAULT_FROM_EMAIL, [email])
#         email.attach_alternative(html_content,"text/html")
#         email.send()
        
#         messages.info(request,'Successfully Submitted!')
#         return redirect('Thanks-page')

#     queryset = MenuByFunctionModel.objects.all()
#     alt_text = request.GET.get('alt_text')
#     menu_price = request.GET.get('menu_price')
#     if alt_text:
#         queryset = queryset.filter(alt_text__exact=alt_text)
#     if menu_price:
#         queryset = queryset.filter(menu_price__contains=menu_price)

#     context = {'photos': queryset}
#     return render(request, 'front/package-detail.html', context)
                                         
                                         
# class Package_detail(ListView):
#     model = MenuByFunctionModel
#     template_name = 'front/package-detail.html'
#     context_object_name = 'photos'

#     def get_queryset(self):
#         menu_name = self.request.GET.get('menu_name')
#         menu_price = self.request.GET.get('menu_price')

#         if not menu_name or not menu_price:
#             raise Http404("menu_name and menu_price are required")

#         return self.model.objects.filter(menu_name=menu_name, menu_price=menu_price)

# class Package_detail(ListView):
#     model = MenuByFunctionModel
#     template_name = 'front/package-detail.html'
#     context_object_name = 'photos'

#     def get_queryset(self):
#         menu_name = self.request.GET.get('menu_name')
#         menu_price = self.request.GET.get('menu_price')
#         title = self.request.GET.get('title')

#         if not menu_name or not title:
#             raise Http404("menu_name and menu_price are required")

#         return self.model.objects.filter(menu_name=menu_name, menu_price=menu_price,title=title)


# def search(request):
#   queryset_list = AddFunctionModel.objects.order_by('-publish')

#   # Bedrooms
#   if 'function_name' in request.GET:
#     function_name = request.GET['function_name']
#     if function_name:
#       queryset_list = queryset_list.filter(function_name__iexact=function_name)



#   context = {
#     # 'state_choices': state_choices,
#     # 'function_choices': function_choices,
#     # 'price_choices': price_choices,
#     'listings': queryset_list,
#     'values': request.GET
#   }

#   return render(request, 'front/search.html', context)

def Index(request):
    if request.method=='POST':
        name=request.POST['name']
        email=request.POST['email']
        phone = request.POST['phone']
        venue=request.POST['venue']
        message = request.POST['message']
        capacity =request.POST['capacity']
        function = request.POST['function']
        budget = request.POST['budget']
        func = FunctionModel.objects.all()
        date = request.POST['date']
        clientKey = request.POST['g-recaptcha-response']
        secretKey="6Lcnwp8hAAAAAFNda3ZsfwMzDsVOsLU5yMBoZpa0"
        captchaData={
            'secret':secretKey,
            'response':clientKey,
        }
        r = requests.post("https://www.google.com/recaptcha/api/siteverify",data=captchaData)
        response=json.loads(r.text)
        verify= response['success']
        
        user=ContactModel.objects.create(name=name,email=email,phone=phone,venue=venue,date=date,budget=budget,capacity=capacity,message=message)
        user.save()
        html_content = render_to_string("front/email.html")
        text_content = strip_tags(html_content)
        newemail = "catering@ambria.in"
        email = EmailMultiAlternatives('Thank you for showing interest in GetYourMenu ', text_content , settings.DEFAULT_FROM_EMAIL, [newemail])
        email.attach_alternative(html_content,"text/html")
        
        email.send()
        
        messages.info(request,'Successfully Submitted!')
        return redirect('Thanks-page')
        
        
    slider = Slider.objects.all()
    func = FunctionModel.objects.all()
    menu = Elements_Of_Menu.objects.all()
    ename = Add_Elements.objects.all()
    mname = FunctionModel.objects.all()
    image = AddFunctionModel.objects.all()
    fname = AddFunctionModel.objects.all()
    usp  = USP.objects.all()
    homecontent = Homecontent.objects.all()
    social = SocialMedia.objects.all()
    post = Post.objects.all()
    recent_post = Post.objects.filter(is_draft=False).order_by('-publish')[0:3]
    cta = CTA.objects.all() 
    # result = requests["function_name"]
    # f = ListingFilter(request.GET, queryset=AddFunctionModel.objects.all())
    # poo = ListingFilterMenu(request.GET, queryset=MenuByFunctionModel.objects.filter()[0:6])
    # m  = MenuByFunctionModel.objects.filter(title=func)
    m  = MenuByFunctionModel.objects.all()
    testimonials = Testimonial.objects.all()
    video_testimonials = VideoTestimonial.objects.filter(is_active=True)
    
    
    
    new ={
        'sliders' : slider,    
        'menus':menu,
        'enames': ename,
        'fnames' : fname ,
        'mnames': mname,
        'posts': post,
        'recent_posts':recent_post,
        'usps' : usp,
        'homecontents':homecontent,
        'socials' : social,
        'funcs':func,
        'images' : image,
        'ctas' : cta,       
        # 'fs':f,
         'ms' : m,
        # 'poos':poo,
        'testimonials': testimonials,
        'video_testimonials': video_testimonials
        
    }

    return render(request, 'front/index.html',new)


##################################################### ABOUT #########################################
def About(request):
    if request.method=='POST':
        name=request.POST['name']
        email=request.POST['email']
        phone = request.POST['phone']
        venue=request.POST['venue']
        message = request.POST['message']
        capacity =request.POST['capacity']
        function = request.POST['function']
        budget = request.POST['budget']
        func = FunctionModel.objects.all()
        date = request.POST['date']
        clientKey = request.POST['g-recaptcha-response']
        secretKey="6Lcnwp8hAAAAAFNda3ZsfwMzDsVOsLU5yMBoZpa0"
        captchaData={
            'secret':secretKey,
            'response':clientKey,
        }
        r = requests.post(" https://www.google.com/recaptcha/api/siteverify",data=captchaData)
        response=json.loads(r.text)
        verify= response['success']
        
        user=ContactModel.objects.create(name=name,email=email,phone=phone,venue=venue,date=date,budget=budget,capacity=capacity,message=message)
        user.save()
    about = Aboutus.objects.all()
    social = SocialMedia.objects.all()
    func = FunctionModel.objects.all()
    
    context = {
    'abouts' : about,
    'socials': social,
    'funcs':func,
    
    }
    return render(request,'front/about.html',context)
    



########################################################### CONTACT ###################################
def Contact(request):
    social = SocialMedia.objects.all()
    if request.method=='POST':
        name=request.POST['name']
        email=request.POST['email']
        phone = request.POST['phone']
        venue=request.POST['venue']
        message = request.POST['message']
        capacity =request.POST['capacity']
        function = request.POST['function']
        budget = request.POST['budget']
        func = FunctionModel.objects.all()
        date = request.POST['date']
        clientKey = request.POST['g-recaptcha-response']
        secretKey="6Lcnwp8hAAAAAFNda3ZsfwMzDsVOsLU5yMBoZpa0"
        captchaData={
            'secret':secretKey,
            'response':clientKey,
        }
        r = requests.post(" https://www.google.com/recaptcha/api/siteverify",data=captchaData)
        response=json.loads(r.text)
        verify= response['success']
        
        user=ContactModel.objects.create(name=name,email=email,phone=phone,venue=venue,date=date,budget=budget,capacity=capacity,message=message)
        user.save()
        return redirect('Thanks-page')
        
    return render(request, 'front/contact.html', {'socials': social})
    

	
def Portfolio_View(request):
    if request.method=='POST':
        name=request.POST['name']
        email=request.POST['email']
        phone = request.POST['phone']
        venue=request.POST['venue']
        message = request.POST['message']
        capacity =request.POST['capacity']
        function = request.POST['function']
        budget = request.POST['budget']
        func = FunctionModel.objects.all()
        date = request.POST['date']
        clientKey = request.POST['g-recaptcha-response']
        secretKey="6Lcnwp8hAAAAAFNda3ZsfwMzDsVOsLU5yMBoZpa0"
        captchaData={
            'secret':secretKey,
            'response':clientKey,
        }
        r = requests.post(" https://www.google.com/recaptcha/api/siteverify",data=captchaData)
        response=json.loads(r.text)
        verify= response['success']
        
        user=ContactModel.objects.create(name=name,email=email,phone=phone,venue=venue,date=date,budget=budget,capacity=capacity,message=message)
        user.save()
        return redirect('Thanks-page')
    portfolio = Portfolio.objects.all()
    func = FunctionModel.objects.all()
    gallery = Gallery.objects.all()
    galcat  = Gallery_Category.objects.all()
    social = SocialMedia.objects.all()

    context ={
    'portfolios' : portfolio,
    'gallerys'   : gallery,
    'galcats'    : galcat,
    'socials' : social,
    'funcs':func,
   
    }
    return render(request, 'front/portfolio.html', context )
    

    
def Clientele(request):
    if request.method=='POST':
        name=request.POST['name']
        email=request.POST['email']
        phone = request.POST['phone']
        venue=request.POST['venue']
        message = request.POST['message']
        capacity =request.POST['capacity']
        function = request.POST['function']
        budget = request.POST['budget']
        func = FunctionModel.objects.all()
        date = request.POST['date']
        clientKey = request.POST['g-recaptcha-response']
        secretKey="6Lcnwp8hAAAAAFNda3ZsfwMzDsVOsLU5yMBoZpa0"
        captchaData={
            'secret':secretKey,
            'response':clientKey,
        }
        r = requests.post(" https://www.google.com/recaptcha/api/siteverify",data=captchaData)
        response=json.loads(r.text)
        verify= response['success']
        
        user=ContactModel.objects.create(name=name,email=email,phone=phone,venue=venue,date=date,budget=budget,capacity=capacity,message=message)
        user.save()
        return redirect('Thanks-page')
    venue = Venue.objects.all()
    corporate = Corporate.objects.all()
    government = Goverment_Organization.objects.all()
    testimonial = Testimonial.objects.all()
    func = FunctionModel.objects.all()
    you = Youtube_Testimonial.objects.all()
    social = SocialMedia.objects.all()
    context = {
    'venues' : venue,
    'corporates': corporate,
    'govt': government,
    'testimonials': testimonial,
    'socials' : social,
    'yous' : you,
    'funcs':func,

     }
    return render(request, 'front/clientele.html', context)
    
def Ocassion(request):
    if request.method=='POST':
        name=request.POST['name']
        email=request.POST['email']
        phone = request.POST['phone']
        venue=request.POST['venue']
        message = request.POST['message']
        capacity =request.POST['capacity']
        function = request.POST['function']
        budget = request.POST['budget']
        func = FunctionModel.objects.all()
        date = request.POST['date']
        clientKey = request.POST['g-recaptcha-response']
        secretKey="6Lcnwp8hAAAAAFNda3ZsfwMzDsVOsLU5yMBoZpa0"
        captchaData={
            'secret':secretKey,
            'response':clientKey,
        }
        r = requests.post(" https://www.google.com/recaptcha/api/siteverify",data=captchaData)
        response=json.loads(r.text)
        verify= response['success']
        
        user=ContactModel.objects.create(name=name,email=email,phone=phone,venue=venue,date=date,budget=budget,capacity=capacity,message=message)
        user.save()
        return redirect('Thanks-page')
    social = SocialMedia.objects.all()
    occasion = myOccasion.objects.all()
    func = FunctionModel.objects.all()
    recent_post = Post.objects.filter(is_draft=False).order_by('-publish')[:3]
    
    context = {
    'socials' : social,
    'occasions': occasion,
    'recent_posts': recent_post,
    'funcs':func,
    }
    
    return render(request, 'front/ocassion.html', context)
    
def OccasionDetail(request, slug):
    post = get_object_or_404(myOccasion, slug=slug)
    photos = mygallery.objects.filter(page=post)
    recent_post = Post.objects.filter(is_draft=False).order_by('-publish')[:3]
    occasion = myOccasion.objects.all()
    social = SocialMedia.objects.all()
    func = FunctionModel.objects.all()
    if request.method == "POST":
        enquiry_form = EnquiryForm(request.POST)
        if enquiry_form.is_valid():
            name = enquiry_form.cleaned_data['name']
            mobile = enquiry_form.cleaned_data['mobile']
            function = enquiry_form.cleaned_data['function']
            date = enquiry_form.cleaned_data['date']
            capacity = enquiry_form.cleaned_data['capacity']
            user = EnquiryModel.objects.create(name=name, date=date, capacity=capacity, function=function, mobile=mobile)
            user.save()
            return redirect('Thanks-page')
    else:
        enquiry_form = EnquiryForm()
    
    if request.method == 'POST':
        contact_form = ContactForm(request.POST)
        if contact_form.is_valid():
            name = contact_form.cleaned_data['name']
            email = contact_form.cleaned_data['email']
            phone = contact_form.cleaned_data['phone']
            venue = contact_form.cleaned_data['venue']
            message = contact_form.cleaned_data['message']
            capacity = contact_form.cleaned_data['capacity']
            function = contact_form.cleaned_data['function']
            budget = contact_form.cleaned_data['budget']
            func = FunctionModel.objects.all()
            date = contact_form.cleaned_data['date']
            clientKey = request.POST['g-recaptcha-response']
            secretKey="6Lcnwp8hAAAAAFNda3ZsfwMzDsVOsLU5yMBoZpa0"
            captchaData={
                'secret':secretKey,
                'response':clientKey,
            }
            r = requests.post(" https://www.google.com/recaptcha/api/siteverify",data=captchaData)
            response=json.loads(r.text)
            verify= response['success']

            user = ContactModel.objects.create(name=name, email=email, phone=phone, venue=venue, date=date, budget=budget, capacity=capacity, message=message)
            user.save()
            return redirect('Thanks-page')
    else:
        contact_form = ContactForm()
    
    return render(request, 'front/occasion-detail.html', {
        
        'occasions': occasion,
        'socials' : social,
        
         'post': post,
        'photos': photos,
        'recent_posts': recent_post,
        'funcs': func,
        'enquiry_form': enquiry_form,
        'contact_form': contact_form,
    
    })

    
def CuisineView(request):
    if request.method=='POST':
        name=request.POST['name']
        email=request.POST['email']
        phone = request.POST['phone']
        venue=request.POST['venue']
        message = request.POST['message']
        capacity =request.POST['capacity']
        function = request.POST['function']
        budget = request.POST['budget']
        func = FunctionModel.objects.all()
        date = request.POST['date']
        clientKey = request.POST['g-recaptcha-response']
        secretKey="6Lcnwp8hAAAAAFNda3ZsfwMzDsVOsLU5yMBoZpa0"
        captchaData={
            'secret':secretKey,
            'response':clientKey,
        }
        r = requests.post(" https://www.google.com/recaptcha/api/siteverify",data=captchaData)
        response=json.loads(r.text)
        verify= response['success']
        
        user=ContactModel.objects.create(name=name,email=email,phone=phone,venue=venue,date=date,budget=budget,capacity=capacity,message=message)
        user.save()
        return redirect('Thanks-page')
    cuisine = Cuisine.objects.all()
    social = SocialMedia.objects.all()
    func = FunctionModel.objects.all()
    recent_post = Post.objects.filter(is_draft=False).order_by('-publish')[:3]
    context = {
        'cuisines': cuisine,
        'socials' : social,
        'recent_posts': recent_post,
        'funcs':func,
        
        
    }
    return render(request, 'front/cuisine.html', context)

def CuisineDetail(request, slug):
    social = SocialMedia.objects.all()
    post = get_object_or_404(Cuisine, slug=slug)
    photos = cuisinegallery.objects.filter(page=post)
    recent_post = Post.objects.filter(is_draft=False).order_by('-publish')[:3]
    cuisine = Cuisine.objects.all()
    if request.method == "POST":
        enquiry_form = EnquiryForm(request.POST)
        if enquiry_form.is_valid():
            name = enquiry_form.cleaned_data['name']
            mobile = enquiry_form.cleaned_data['mobile']
            function = enquiry_form.cleaned_data['function']
            date = enquiry_form.cleaned_data['date']
            capacity = enquiry_form.cleaned_data['capacity']
            user = EnquiryModel.objects.create(name=name, date=date, capacity=capacity, function=function, mobile=mobile)
            user.save()
    else:
        enquiry_form = EnquiryForm()
    
    if request.method == 'POST':
        contact_form = ContactForm(request.POST)
        if contact_form.is_valid():
            name = contact_form.cleaned_data['name']
            email = contact_form.cleaned_data['email']
            phone = contact_form.cleaned_data['phone']
            venue = contact_form.cleaned_data['venue']
            message = contact_form.cleaned_data['message']
            capacity = contact_form.cleaned_data['capacity']
            function = contact_form.cleaned_data['function']
            budget = contact_form.cleaned_data['budget']
            func = FunctionModel.objects.all()
            date = contact_form.cleaned_data['date']
            clientKey = request.POST['g-recaptcha-response']
            secretKey="6Lcnwp8hAAAAAFNda3ZsfwMzDsVOsLU5yMBoZpa0"
            captchaData={
                'secret':secretKey,
                'response':clientKey,
            }
            r = requests.post(" https://www.google.com/recaptcha/api/siteverify",data=captchaData)
            response=json.loads(r.text)
            verify= response['success']

            user = ContactModel.objects.create(name=name, email=email, phone=phone, venue=venue, date=date, budget=budget, capacity=capacity, message=message)
            user.save()
            return redirect('Thanks-page')
    else:
        contact_form = ContactForm()
    
    return render(request, 'front/cuisine-detail.html', 
         {
        'post': post,
        'photos': photos,
        'recent_posts': recent_post,
        
        'enquiry_form': enquiry_form,
        'contact_form': contact_form,
     'socials' : social,
        
         'cuisines': cuisine,
         
        })


 
def Elements_Variety(request,slug):
    post = get_object_or_404(Add_Elements, slug=slug)
    photos = Elementsgallery.objects.filter(page=post)
    recent_post = Post.objects.filter(is_draft=False).order_by('-publish')[:3]
    occasion = myOccasion.objects.all()
    social = SocialMedia.objects.all()
    func = FunctionModel.objects.all()
    if request.method == "POST":
        enquiry_form = EnquiryForm(request.POST)
        if enquiry_form.is_valid():
            name = enquiry_form.cleaned_data['name']
            mobile = enquiry_form.cleaned_data['mobile']
            function = enquiry_form.cleaned_data['function']
            date = enquiry_form.cleaned_data['date']
            capacity = enquiry_form.cleaned_data['capacity']
            user = EnquiryModel.objects.create(name=name, date=date, capacity=capacity, function=function, mobile=mobile)
            user.save()
    else:
        enquiry_form = EnquiryForm()
    
    if request.method == 'POST':
        contact_form = ContactForm(request.POST)
        if contact_form.is_valid():
            name = contact_form.cleaned_data['name']
            email = contact_form.cleaned_data['email']
            phone = contact_form.cleaned_data['phone']
            venue = contact_form.cleaned_data['venue']
            message = contact_form.cleaned_data['message']
            capacity = contact_form.cleaned_data['capacity']
            function = contact_form.cleaned_data['function']
            budget = contact_form.cleaned_data['budget']
            func = FunctionModel.objects.all()
            date = contact_form.cleaned_data['date']
            clientKey = request.POST['g-recaptcha-response']
            secretKey="6Lcnwp8hAAAAAFNda3ZsfwMzDsVOsLU5yMBoZpa0"
            captchaData={
                'secret':secretKey,
                'response':clientKey,
            }
            r = requests.post(" https://www.google.com/recaptcha/api/siteverify",data=captchaData)
            response=json.loads(r.text)
            verify= response['success']

            user = ContactModel.objects.create(name=name, email=email, phone=phone, venue=venue, date=date, budget=budget, capacity=capacity, message=message)
            user.save()
            return redirect('Thanks-page')
    else:
        contact_form = ContactForm()
    elem = get_object_or_404(Add_Elements,slug=slug)
    elegallery = Elementsgallery.objects.filter(page=elem)
    return render(request, 'front/element_menu.html',{
        'elem' : elem,
        'elegallery' : elegallery,
         'socials' : social,
        
        })

       
        
#########################################  BLOG  ################################################


# def blog_page(request):
#     return render(request, 'front/blog.html')

def Home(request):
    return render(request,'front/home.html')

def FunctionSingle(request,slug):
    if request.method=='POST':
        name=request.POST['name']
        email=request.POST['email']
        phone = request.POST['phone']
        venue=request.POST['venue']
        message = request.POST['message']
        capacity =request.POST['capacity']
        function = request.POST['function']
        budget = request.POST['budget']
        func = FunctionModel.objects.all()
        date = request.POST['date']
        clientKey = request.POST['g-recaptcha-response']
        secretKey="6Lcnwp8hAAAAAFNda3ZsfwMzDsVOsLU5yMBoZpa0"
        captchaData={
            'secret':secretKey,
            'response':clientKey,
        }
        r = requests.post(" https://www.google.com/recaptcha/api/siteverify",data=captchaData)
        response=json.loads(r.text)
        verify= response['success']
        
        user=ContactModel.objects.create(name=name,email=email,phone=phone,venue=venue,date=date,budget=budget,capacity=capacity,message=message)
        user.save()
        return redirect('Thanks-page')
    testimonial = Testimonial.objects.all()
    function = FunctionModel.objects.get(slug=slug)
    photos = myfuncgallery.objects.filter(page=function)
    faq = Faqmodel.objects.filter(page=function)
    you = Youtube_Testimonial.objects.all()
    social = SocialMedia.objects.all()
    recent_post = Post.objects.filter(is_draft=False).order_by('-publish')[:3]
    func = FunctionModel.objects.all()
    myfuncgal = myfuncgallery.objects.all()
    image = AddFunctionModel.objects.filter(slug=function)
    m  = MenuByFunctionModel.objects.filter(title=function)

    context = {
    'testimonials':testimonial,
    'function' : function,
    'photos':photos,
    'faqs' : faq,
    'yous' : you,
    'socials' : social,
    'recent_posts': recent_post,
    'funcs' : func,
   
    'ms':m,
    'images':image,
    }
    return render(request,'front/function-single.html',context)

def Header(request):
    func = FunctionModel.objects.all()

    context = {
    'funcs' : func,
    }

    return render(request,'front/header.html',context)

def Function(request):
    if request.method=='POST':
        name=request.POST['name']
        email=request.POST['email']
        phone = request.POST['phone']
        venue=request.POST['venue']
        message = request.POST['message']
        capacity =request.POST['capacity']
        function = request.POST['function']
        budget = request.POST['budget']
        func = FunctionModel.objects.all()
        date = request.POST['date']
        clientKey = request.POST['g-recaptcha-response']
        secretKey="6Lcnwp8hAAAAAFNda3ZsfwMzDsVOsLU5yMBoZpa0"
        captchaData={
            'secret':secretKey,
            'response':clientKey,
        }
        r = requests.post(" https://www.google.com/recaptcha/api/siteverify",data=captchaData)
        response=json.loads(r.text)
        verify= response['success']
        
        user=ContactModel.objects.create(name=name,email=email,phone=phone,venue=venue,date=date,budget=budget,capacity=capacity,message=message)
        user.save()
        return redirect('Thanks-page')
    func = FunctionModel.objects.all()
    addfunc = AddFunctionModel.objects.all()
    testimonial = Testimonial.objects.all()
    you = Youtube_Testimonial.objects.all()
    social = SocialMedia.objects.all()
    recent_post = Post.objects.filter(is_draft=False).order_by('-publish')[:3]

    context ={
     'funcs' : func,
     'testimonials':testimonial,
     'addfuncs' : addfunc, 
     'yous' : you,
     'socials' : social,
      'recent_posts': recent_post,
        
    }


    return render(request,'front/function.html',context)
    
def Footer(request):
    social = SocialMedia.objects.all()

    context = {
    'socials' : social,

    }

    return render(request, 'front/footer.html',context)
    








def Test(request):
    return render(request,'front/test.html')
 
def Wedding(request):
    recent_post = Post.objects.filter(is_draft=False).order_by('-publish')[:3]
    occasion = myOccasion.objects.all()
    social = SocialMedia.objects.all()
    
    if request.method == "POST":
        enquiry_form = EnquiryForm(request.POST)
        if enquiry_form.is_valid():
            name = enquiry_form.cleaned_data['name']
            mobile = enquiry_form.cleaned_data['mobile']
            function = enquiry_form.cleaned_data['function']
            date = enquiry_form.cleaned_data['date']
            capacity = enquiry_form.cleaned_data['capacity']
            user = EnquiryModel.objects.create(name=name, date=date, capacity=capacity, function=function, mobile=mobile)
            user.save()
            return redirect('Thanks-page')
    else:
        enquiry_form = EnquiryForm()
    
    if request.method == 'POST':
        contact_form = ContactForm(request.POST)
        if contact_form.is_valid():
            name = contact_form.cleaned_data['name']
            email = contact_form.cleaned_data['email']
            phone = contact_form.cleaned_data['phone']
            venue = contact_form.cleaned_data['venue']
            message = contact_form.cleaned_data['message']
            capacity = contact_form.cleaned_data['capacity']
            function = contact_form.cleaned_data['function']
            budget = contact_form.cleaned_data['budget']
            func = FunctionModel.objects.all()
            date = contact_form.cleaned_data['date']
            clientKey = request.POST['g-recaptcha-response']
            secretKey="6Lcnwp8hAAAAAFNda3ZsfwMzDsVOsLU5yMBoZpa0"
            captchaData={
                'secret':secretKey,
                'response':clientKey,
            }
            r = requests.post(" https://www.google.com/recaptcha/api/siteverify",data=captchaData)
            response=json.loads(r.text)
            verify= response['success']

            user = ContactModel.objects.create(name=name, email=email, phone=phone, venue=venue, date=date, budget=budget, capacity=capacity, message=message)
            user.save()
            return redirect('Thanks-page')
    else:
        contact_form = ContactForm()
    func = FunctionModel.objects.all()
    
    return render(request,'front/wedding-aniversary.html',{'recent_posts': recent_post, 'occasions': occasion,})

def Pool(request):
    recent_post = Post.objects.filter(is_draft=False).order_by('-publish')[:3]
    occasion = myOccasion.objects.all()
    social = SocialMedia.objects.all()
    
    if request.method == "POST":
        enquiry_form = EnquiryForm(request.POST)
        if enquiry_form.is_valid():
            name = enquiry_form.cleaned_data['name']
            mobile = enquiry_form.cleaned_data['mobile']
            function = enquiry_form.cleaned_data['function']
            date = enquiry_form.cleaned_data['date']
            capacity = enquiry_form.cleaned_data['capacity']
            user = EnquiryModel.objects.create(name=name, date=date, capacity=capacity, function=function, mobile=mobile)
            user.save()
            return redirect('Thanks-page')
    else:
        enquiry_form = EnquiryForm()
    
    if request.method == 'POST':
        contact_form = ContactForm(request.POST)
        if contact_form.is_valid():
            name = contact_form.cleaned_data['name']
            email = contact_form.cleaned_data['email']
            phone = contact_form.cleaned_data['phone']
            venue = contact_form.cleaned_data['venue']
            message = contact_form.cleaned_data['message']
            capacity = contact_form.cleaned_data['capacity']
            function = contact_form.cleaned_data['function']
            budget = contact_form.cleaned_data['budget']
            func = FunctionModel.objects.all()
            date = contact_form.cleaned_data['date']
            clientKey = request.POST['g-recaptcha-response']
            secretKey="6Lcnwp8hAAAAAFNda3ZsfwMzDsVOsLU5yMBoZpa0"
            captchaData={
                'secret':secretKey,
                'response':clientKey,
            }
            r = requests.post(" https://www.google.com/recaptcha/api/siteverify",data=captchaData)
            response=json.loads(r.text)
            verify= response['success']

            user = ContactModel.objects.create(name=name, email=email, phone=phone, venue=venue, date=date, budget=budget, capacity=capacity, message=message)
            user.save()
            return redirect('Thanks-page')
    else:
        contact_form = ContactForm()
    func = FunctionModel.objects.all()
    return render(request,'front/poolparty.html',{'recent_posts': recent_post, 'occasions': occasion,})

def Newyear(request):
    recent_post = Post.objects.filter(is_draft=False).order_by('-publish')[:3]
    occasion = myOccasion.objects.all()
    social = SocialMedia.objects.all()
    
    if request.method == "POST":
        enquiry_form = EnquiryForm(request.POST)
        if enquiry_form.is_valid():
            name = enquiry_form.cleaned_data['name']
            mobile = enquiry_form.cleaned_data['mobile']
            function = enquiry_form.cleaned_data['function']
            date = enquiry_form.cleaned_data['date']
            capacity = enquiry_form.cleaned_data['capacity']
            user = EnquiryModel.objects.create(name=name, date=date, capacity=capacity, function=function, mobile=mobile)
            user.save()
            return redirect('Thanks-page')
    else:
        enquiry_form = EnquiryForm()
    
    if request.method == 'POST':
        contact_form = ContactForm(request.POST)
        if contact_form.is_valid():
            name = contact_form.cleaned_data['name']
            email = contact_form.cleaned_data['email']
            phone = contact_form.cleaned_data['phone']
            venue = contact_form.cleaned_data['venue']
            message = contact_form.cleaned_data['message']
            capacity = contact_form.cleaned_data['capacity']
            function = contact_form.cleaned_data['function']
            budget = contact_form.cleaned_data['budget']
            func = FunctionModel.objects.all()
            date = contact_form.cleaned_data['date']
            clientKey = request.POST['g-recaptcha-response']
            secretKey="6Lcnwp8hAAAAAFNda3ZsfwMzDsVOsLU5yMBoZpa0"
            captchaData={
                'secret':secretKey,
                'response':clientKey,
            }
            r = requests.post(" https://www.google.com/recaptcha/api/siteverify",data=captchaData)
            response=json.loads(r.text)
            verify= response['success']

            user = ContactModel.objects.create(name=name, email=email, phone=phone, venue=venue, date=date, budget=budget, capacity=capacity, message=message)
            user.save()
            return redirect('Thanks-page')
    else:
        contact_form = ContactForm()
    func = FunctionModel.objects.all()
    
    return render(request,'front/new-year.html',{'recent_posts': recent_post, 'occasions': occasion,})
    
    
 

def SikhWedding(request):
    try:
        social = SocialMedia.objects.all()
        recent_post = Post.objects.filter(is_draft=False).order_by('-publish')[:3]
        culture = Culture.objects.all()
        func = FunctionModel.objects.all()
    except Exception:
        return render(request, 'front/404.html', status=404)

    enquiry_form = EnquiryForm()
    contact_form = ContactForm()

    # ================= HANDLE POST =================
    if request.method == "POST":

        # 🔹 Enquiry form
        if 'mobile' in request.POST:
            enquiry_form = EnquiryForm(request.POST)
            if enquiry_form.is_valid():
                EnquiryModel.objects.create(
                    name=enquiry_form.cleaned_data['name'],
                    mobile=enquiry_form.cleaned_data['mobile'],
                    function=enquiry_form.cleaned_data['function'],
                    date=enquiry_form.cleaned_data['date'],
                    capacity=enquiry_form.cleaned_data['capacity'],
                )
                return redirect('Thanks-page')

        # 🔹 Contact form
        elif 'email' in request.POST:
            contact_form = ContactForm(request.POST)
            if contact_form.is_valid():
                try:
                    clientKey = request.POST.get('g-recaptcha-response')
                    secretKey = "6Lcnwp8hAAAAAFNda3ZsfwMzDsVOsLU5yMBoZpa0"

                    captchaData = {
                        'secret': secretKey,
                        'response': clientKey,
                    }

                    r = requests.post(
                        "https://www.google.com/recaptcha/api/siteverify",
                        data=captchaData,
                        timeout=5
                    )

                    response = r.json()

                    if response.get('success'):
                        ContactModel.objects.create(
                            name=contact_form.cleaned_data['name'],
                            email=contact_form.cleaned_data['email'],
                            phone=contact_form.cleaned_data['phone'],
                            venue=contact_form.cleaned_data['venue'],
                            date=contact_form.cleaned_data['date'],
                            budget=contact_form.cleaned_data['budget'],
                            capacity=contact_form.cleaned_data['capacity'],
                            message=contact_form.cleaned_data['message'],
                        )
                        return redirect('Thanks-page')
                    else:
                        return render(request, 'front/404.html', status=404)

                except Exception:
                    return render(request, 'front/404.html', status=404)

    # ================= SAFE TEMPLATE LOAD =================
    try:
        get_template('front/sikh-wedding.html')
    except:
        return render(request, 'front/404.html', status=404)

    return render(request, 'front/sikh-wedding.html', {
        'recent_posts': recent_post,
        'cultures': culture,
        'funcs': func,
        'enquiry_form': enquiry_form,
        'contact_form': contact_form,
        'socials': social,
    }) 
   
    
# def SikhWedding(request):
#     social = SocialMedia.objects.all()
#     recent_post = Post.objects.filter(is_draft=False).order_by('-publish')[:3]
#     culture = Culture.objects.all()
#     func = FunctionModel.objects.all()
    
#     if request.method == "POST":
#         enquiry_form = EnquiryForm(request.POST)
#         if enquiry_form.is_valid():
#             name = enquiry_form.cleaned_data['name']
#             mobile = enquiry_form.cleaned_data['mobile']
#             function = enquiry_form.cleaned_data['function']
#             date = enquiry_form.cleaned_data['date']
#             capacity = enquiry_form.cleaned_data['capacity']
#             user = EnquiryModel.objects.create(name=name, date=date, capacity=capacity, function=function, mobile=mobile)
#             user.save()
#             return redirect('Thanks-page')
#     else:
#         enquiry_form = EnquiryForm()
    
#     if request.method == 'POST':
#         contact_form = ContactForm(request.POST)
#         if contact_form.is_valid():
#             name = contact_form.cleaned_data['name']
#             email = contact_form.cleaned_data['email']
#             phone = contact_form.cleaned_data['phone']
#             venue = contact_form.cleaned_data['venue']
#             message = contact_form.cleaned_data['message']
#             capacity = contact_form.cleaned_data['capacity']
#             function = contact_form.cleaned_data['function']
#             budget = contact_form.cleaned_data['budget']
#             func = FunctionModel.objects.all()
#             date = contact_form.cleaned_data['date']
#             clientKey = request.POST['g-recaptcha-response']
#             secretKey="6Lcnwp8hAAAAAFNda3ZsfwMzDsVOsLU5yMBoZpa0"
#             captchaData={
#                 'secret':secretKey,
#                 'response':clientKey,
#             }
#             r = requests.post(" https://www.google.com/recaptcha/api/siteverify",data=captchaData)
#             response=json.loads(r.text)
#             verify= response['success']

#             user = ContactModel.objects.create(name=name, email=email, phone=phone, venue=venue, date=date, budget=budget, capacity=capacity, message=message)
#             user.save()
#             return redirect('Thanks-page')
#     else:
#         contact_form = ContactForm()
    
#     return render(request, 'front/sikh-wedding.html', {
        
#         'recent_posts': recent_post,
#         'cultures': culture,
#         'funcs': func,
#         'enquiry_form': enquiry_form,
#         'contact_form': contact_form,
#          'socials' : social,
        
#     })


def HinduWedding(request):
    social = SocialMedia.objects.all()
    recent_post = Post.objects.filter(is_draft=False).order_by('-publish')[:3]
    culture = Culture.objects.all()
    func = FunctionModel.objects.all()
    
    if request.method == "POST":
        enquiry_form = EnquiryForm(request.POST)
        if enquiry_form.is_valid():
            name = enquiry_form.cleaned_data['name']
            mobile = enquiry_form.cleaned_data['mobile']
            function = enquiry_form.cleaned_data['function']
            date = enquiry_form.cleaned_data['date']
            capacity = enquiry_form.cleaned_data['capacity']
            user = EnquiryModel.objects.create(name=name, date=date, capacity=capacity, function=function, mobile=mobile)
            user.save()
            return redirect('Thanks-page')
    else:
        enquiry_form = EnquiryForm()
    
    if request.method == 'POST':
        contact_form = ContactForm(request.POST)
        if contact_form.is_valid():
            name = contact_form.cleaned_data['name']
            email = contact_form.cleaned_data['email']
            phone = contact_form.cleaned_data['phone']
            venue = contact_form.cleaned_data['venue']
            message = contact_form.cleaned_data['message']
            capacity = contact_form.cleaned_data['capacity']
            function = contact_form.cleaned_data['function']
            budget = contact_form.cleaned_data['budget']
            func = FunctionModel.objects.all()
            date = contact_form.cleaned_data['date']
            clientKey = request.POST['g-recaptcha-response']
            secretKey="6Lcnwp8hAAAAAFNda3ZsfwMzDsVOsLU5yMBoZpa0"
            captchaData={
                'secret':secretKey,
                'response':clientKey,
            }
            r = requests.post(" https://www.google.com/recaptcha/api/siteverify",data=captchaData)
            response=json.loads(r.text)
            verify= response['success']

            user = ContactModel.objects.create(name=name, email=email, phone=phone, venue=venue, date=date, budget=budget, capacity=capacity, message=message)
            user.save()
            return redirect('Thanks-page')
    else:
        contact_form = ContactForm()
    
    return render(request, 'front/hindu-wedding.html', {
        
        'recent_posts': recent_post,
        'cultures': culture,
        'funcs': func,
        'enquiry_form': enquiry_form,
        'contact_form': contact_form,
         'socials' : social,
        
    })

    

def JainWedding(request):
    social = SocialMedia.objects.all()
    recent_post = Post.objects.filter(is_draft=False).order_by('-publish')[:3]
    culture = Culture.objects.all()
    func = FunctionModel.objects.all()
    
    if request.method == "POST":
        enquiry_form = EnquiryForm(request.POST)
        if enquiry_form.is_valid():
            name = enquiry_form.cleaned_data['name']
            mobile = enquiry_form.cleaned_data['mobile']
            function = enquiry_form.cleaned_data['function']
            date = enquiry_form.cleaned_data['date']
            capacity = enquiry_form.cleaned_data['capacity']
            user = EnquiryModel.objects.create(name=name, date=date, capacity=capacity, function=function, mobile=mobile)
            user.save()
            return redirect('Thanks-page')
    else:
        enquiry_form = EnquiryForm()
    
    if request.method == 'POST':
        contact_form = ContactForm(request.POST)
        if contact_form.is_valid():
            name = contact_form.cleaned_data['name']
            email = contact_form.cleaned_data['email']
            phone = contact_form.cleaned_data['phone']
            venue = contact_form.cleaned_data['venue']
            message = contact_form.cleaned_data['message']
            capacity = contact_form.cleaned_data['capacity']
            function = contact_form.cleaned_data['function']
            budget = contact_form.cleaned_data['budget']
            func = FunctionModel.objects.all()
            date = contact_form.cleaned_data['date']
            clientKey = request.POST['g-recaptcha-response']
            secretKey="6Lcnwp8hAAAAAFNda3ZsfwMzDsVOsLU5yMBoZpa0"
            captchaData={
                'secret':secretKey,
                'response':clientKey,
            }
            r = requests.post(" https://www.google.com/recaptcha/api/siteverify",data=captchaData)
            response=json.loads(r.text)
            verify= response['success']

            user = ContactModel.objects.create(name=name, email=email, phone=phone, venue=venue, date=date, budget=budget, capacity=capacity, message=message)
            user.save()
            return redirect('Thanks-page')
    else:
        contact_form = ContactForm()
    
    return render(request, 'front/jain-wedding.html', {
        
        'recent_posts': recent_post,
        'cultures': culture,
        'funcs': func,
        'enquiry_form': enquiry_form,
        'contact_form': contact_form,
         'socials' : social,
        
    })

    
    
    

def Mexican(request):
    social = SocialMedia.objects.all()
    
   
    recent_post = Post.objects.filter(is_draft=False).order_by('-publish')[:3]
    cuisine = Cuisine.objects.all()
    if request.method == "POST":
        enquiry_form = EnquiryForm(request.POST)
        if enquiry_form.is_valid():
            name = enquiry_form.cleaned_data['name']
            mobile = enquiry_form.cleaned_data['mobile']
            function = enquiry_form.cleaned_data['function']
            date = enquiry_form.cleaned_data['date']
            capacity = enquiry_form.cleaned_data['capacity']
            user = EnquiryModel.objects.create(name=name, date=date, capacity=capacity, function=function, mobile=mobile)
            user.save()
    else:
        enquiry_form = EnquiryForm()
    
    if request.method == 'POST':
        contact_form = ContactForm(request.POST)
        if contact_form.is_valid():
            name = contact_form.cleaned_data['name']
            email = contact_form.cleaned_data['email']
            phone = contact_form.cleaned_data['phone']
            venue = contact_form.cleaned_data['venue']
            message = contact_form.cleaned_data['message']
            capacity = contact_form.cleaned_data['capacity']
            function = contact_form.cleaned_data['function']
            budget = contact_form.cleaned_data['budget']
            func = FunctionModel.objects.all()
            date = contact_form.cleaned_data['date']
            clientKey = request.POST['g-recaptcha-response']
            secretKey="6Lcnwp8hAAAAAFNda3ZsfwMzDsVOsLU5yMBoZpa0"
            captchaData={
                'secret':secretKey,
                'response':clientKey,
            }
            r = requests.post(" https://www.google.com/recaptcha/api/siteverify",data=captchaData)
            response=json.loads(r.text)
            verify= response['success']

            user = ContactModel.objects.create(name=name, email=email, phone=phone, venue=venue, date=date, budget=budget, capacity=capacity, message=message)
            user.save()
            return redirect('Thanks-page')
    else:
        contact_form = ContactForm()
    
    return render(request, 'front/mexican-catering.html', 
         {
        
       
        'recent_posts': recent_post,
        
        'enquiry_form': enquiry_form,
        'contact_form': contact_form,
     'socials' : social,
        
         'cuisines': cuisine,
         
        })



def Mughlai(request):
    social = SocialMedia.objects.all()
    
   
    recent_post = Post.objects.filter(is_draft=False).order_by('-publish')[:3]
    cuisine = Cuisine.objects.all()
    if request.method == "POST":
        enquiry_form = EnquiryForm(request.POST)
        if enquiry_form.is_valid():
            name = enquiry_form.cleaned_data['name']
            mobile = enquiry_form.cleaned_data['mobile']
            function = enquiry_form.cleaned_data['function']
            date = enquiry_form.cleaned_data['date']
            capacity = enquiry_form.cleaned_data['capacity']
            user = EnquiryModel.objects.create(name=name, date=date, capacity=capacity, function=function, mobile=mobile)
            user.save()
    else:
        enquiry_form = EnquiryForm()
    
    if request.method == 'POST':
        contact_form = ContactForm(request.POST)
        if contact_form.is_valid():
            name = contact_form.cleaned_data['name']
            email = contact_form.cleaned_data['email']
            phone = contact_form.cleaned_data['phone']
            venue = contact_form.cleaned_data['venue']
            message = contact_form.cleaned_data['message']
            capacity = contact_form.cleaned_data['capacity']
            function = contact_form.cleaned_data['function']
            budget = contact_form.cleaned_data['budget']
            func = FunctionModel.objects.all()
            date = contact_form.cleaned_data['date']
            clientKey = request.POST['g-recaptcha-response']
            secretKey="6Lcnwp8hAAAAAFNda3ZsfwMzDsVOsLU5yMBoZpa0"
            captchaData={
                'secret':secretKey,
                'response':clientKey,
            }
            r = requests.post(" https://www.google.com/recaptcha/api/siteverify",data=captchaData)
            response=json.loads(r.text)
            verify= response['success']

            user = ContactModel.objects.create(name=name, email=email, phone=phone, venue=venue, date=date, budget=budget, capacity=capacity, message=message)
            user.save()
            return redirect('Thanks-page')
    else:
        contact_form = ContactForm()
    
    return render(request, 'front/mughlai-catering.html', 
         {
        
       
        'recent_posts': recent_post,
        
        'enquiry_form': enquiry_form,
        'contact_form': contact_form,
     'socials' : social,
        
         'cuisines': cuisine,
         
        })



def Oriental(request):
    social = SocialMedia.objects.all()
    
   
    recent_post = Post.objects.filter(is_draft=False).order_by('-publish')[:3]
    cuisine = Cuisine.objects.all()
    if request.method == "POST":
        enquiry_form = EnquiryForm(request.POST)
        if enquiry_form.is_valid():
            name = enquiry_form.cleaned_data['name']
            mobile = enquiry_form.cleaned_data['mobile']
            function = enquiry_form.cleaned_data['function']
            date = enquiry_form.cleaned_data['date']
            capacity = enquiry_form.cleaned_data['capacity']
            user = EnquiryModel.objects.create(name=name, date=date, capacity=capacity, function=function, mobile=mobile)
            user.save()
    else:
        enquiry_form = EnquiryForm()
    
    if request.method == 'POST':
        contact_form = ContactForm(request.POST)
        if contact_form.is_valid():
            name = contact_form.cleaned_data['name']
            email = contact_form.cleaned_data['email']
            phone = contact_form.cleaned_data['phone']
            venue = contact_form.cleaned_data['venue']
            message = contact_form.cleaned_data['message']
            capacity = contact_form.cleaned_data['capacity']
            function = contact_form.cleaned_data['function']
            budget = contact_form.cleaned_data['budget']
            func = FunctionModel.objects.all()
            date = contact_form.cleaned_data['date']
            clientKey = request.POST['g-recaptcha-response']
            secretKey="6Lcnwp8hAAAAAFNda3ZsfwMzDsVOsLU5yMBoZpa0"
            captchaData={
                'secret':secretKey,
                'response':clientKey,
            }
            r = requests.post(" https://www.google.com/recaptcha/api/siteverify",data=captchaData)
            response=json.loads(r.text)
            verify= response['success']

            user = ContactModel.objects.create(name=name, email=email, phone=phone, venue=venue, date=date, budget=budget, capacity=capacity, message=message)
            user.save()
            return redirect('Thanks-page')
    else:
        contact_form = ContactForm()
    
    return render(request, 'front/oriental-catering.html', 
         {
        
       
        'recent_posts': recent_post,
        
        'enquiry_form': enquiry_form,
        'contact_form': contact_form,
     'socials' : social,
        
         'cuisines': cuisine,
         
        })



############################################# CULTURE ###########################################



def CultureView(request):
    if request.method=='POST':
        name=request.POST['name']
        email=request.POST['email']
        phone = request.POST['phone']
        venue=request.POST['venue']
        message = request.POST['message']
        capacity =request.POST['capacity']
        function = request.POST['function']
        budget = request.POST['budget']
        func = FunctionModel.objects.all()
        date = request.POST['date']
        clientKey = request.POST['g-recaptcha-response']
        secretKey="6Lcnwp8hAAAAAFNda3ZsfwMzDsVOsLU5yMBoZpa0"
        captchaData={
            'secret':secretKey,
            'response':clientKey,
        }
        r = requests.post(" https://www.google.com/recaptcha/api/siteverify",data=captchaData)
        response=json.loads(r.text)
        verify= response['success']
        
        user=ContactModel.objects.create(name=name,email=email,phone=phone,venue=venue,date=date,budget=budget,capacity=capacity,message=message)
        user.save()
        return redirect('Thanks-page')
    culture = Culture.objects.all()
    social = SocialMedia.objects.all()
    func = FunctionModel.objects.all()
    recent_post = Post.objects.filter(is_draft=False).order_by('-publish')[:3]
    context = {
        'cultures': culture,
        'socials' : social,
        'recent_posts': recent_post,
        'funcs':func,
        
    }
    return render(request, 'front/culture.html', context)

def CultureDetail(request, slug):
    social = SocialMedia.objects.all()
    post = get_object_or_404(Culture, slug=slug)
    photos = culturegallery.objects.filter(page=post)
    recent_post = Post.objects.filter(is_draft=False).order_by('-publish')[:3]
    culture = Culture.objects.all()
    func = FunctionModel.objects.all()
    
    if request.method == "POST":
        enquiry_form = EnquiryForm(request.POST)
        if enquiry_form.is_valid():
            name = enquiry_form.cleaned_data['name']
            mobile = enquiry_form.cleaned_data['mobile']
            function = enquiry_form.cleaned_data['function']
            date = enquiry_form.cleaned_data['date']
            capacity = enquiry_form.cleaned_data['capacity']
            user = EnquiryModel.objects.create(name=name, date=date, capacity=capacity, function=function, mobile=mobile)
            user.save()
            return redirect('Thanks-page')
    else:
        enquiry_form = EnquiryForm()
    
    if request.method == 'POST':
        contact_form = ContactForm(request.POST)
        if contact_form.is_valid():
            name = contact_form.cleaned_data['name']
            email = contact_form.cleaned_data['email']
            phone = contact_form.cleaned_data['phone']
            venue = contact_form.cleaned_data['venue']
            message = contact_form.cleaned_data['message']
            capacity = contact_form.cleaned_data['capacity']
            function = contact_form.cleaned_data['function']
            budget = contact_form.cleaned_data['budget']
            func = FunctionModel.objects.all()
            date = contact_form.cleaned_data['date']
            clientKey = request.POST['g-recaptcha-response']
            secretKey="6Lcnwp8hAAAAAFNda3ZsfwMzDsVOsLU5yMBoZpa0"
            captchaData={
                'secret':secretKey,
                'response':clientKey,
            }
            r = requests.post(" https://www.google.com/recaptcha/api/siteverify",data=captchaData)
            response=json.loads(r.text)
            verify= response['success']

            user = ContactModel.objects.create(name=name, email=email, phone=phone, venue=venue, date=date, budget=budget, capacity=capacity, message=message)
            user.save()
            return redirect('Thanks-page')
    else:
        contact_form = ContactForm()
    
    return render(request, 'front/culture-detail.html', {
        'post': post,
        'photos': photos,
        'recent_posts': recent_post,
        'cultures': culture,
        'funcs': func,
        'enquiry_form': enquiry_form,
        'contact_form': contact_form,
         'socials' : social,
        
    })



############################################# PHONE FOOTER ###########################################


def Phone(request):
    if request.method=='POST':
        name=request.POST['name']
        email=request.POST['email']
        phone = request.POST['phone']
        venue=request.POST['venue']
        message = request.POST['message']
        capacity =request.POST['capacity']
        function = request.POST['function']
        budget = request.POST['budget']
        func = FunctionModel.objects.all()
        date = request.POST['date']
        clientKey = request.POST['g-recaptcha-response']
        secretKey="6Lcnwp8hAAAAAFNda3ZsfwMzDsVOsLU5yMBoZpa0"
        captchaData={
            'secret':secretKey,
            'response':clientKey,
        }
        r = requests.post(" https://www.google.com/recaptcha/api/siteverify",data=captchaData)
        response=json.loads(r.text)
        verify= response['success']
        
        user=ContactModel.objects.create(name=name,email=email,phone=phone,venue=venue,date=date,budget=budget,capacity=capacity,message=message)
        user.save()
        return redirect('Thanks-page')
    return render(request,'front/footer-phone.html')
    
def Header(request):
    return render(request,'front/header.html')



####################################### CMS VIEWS ##################################################



def blog_page(request):
    if request.method=='POST':
        name=request.POST['name']
        email=request.POST['email']
        phone = request.POST['phone']
        venue=request.POST['venue']
        message = request.POST['message']
        capacity =request.POST['capacity']
        function = request.POST['function']
        budget = request.POST['budget']
        func = FunctionModel.objects.all()
        date = request.POST['date']
        clientKey = request.POST['g-recaptcha-response']
        secretKey="6Lcnwp8hAAAAAFNda3ZsfwMzDsVOsLU5yMBoZpa0"
        captchaData={
            'secret':secretKey,
            'response':clientKey,
        }
        r = requests.post(" https://www.google.com/recaptcha/api/siteverify",data=captchaData)
        response=json.loads(r.text)
        verify= response['success']
        
        user=ContactModel.objects.create(name=name,email=email,phone=phone,venue=venue,date=date,budget=budget,capacity=capacity,message=message)
        user.save()
        return redirect('Thanks-page')
    post = Post.objects.filter(is_draft=False)
    category = BlogCategoryModel.objects.all().order_by('name')
    social = SocialMedia.objects.all()
    recent_post = Post.objects.filter(is_draft=False).order_by('-publish')[:3]
    func = FunctionModel.objects.all()
    context = {
        'posts': post,
        'categories': category,
        'recent_posts': recent_post,
        'socials' : social,
        'funcs':func,

    }
    return render(request, 'front/blog.html', context)

def post_detailsview(request, slug):

    # FIX no crash if post not found
    post = get_object_or_404(Post, slug=slug)

    category = BlogCategoryModel.objects.all().order_by('name')
    social = SocialMedia.objects.all()
    recent_post = Post.objects.filter(is_draft=False).order_by('-publish')[:3]

    form = BlogCommentForm(request.POST or None)

    # ================= CONTACT FORM =================
    if request.method == 'POST' and 'name' in request.POST:
        try:
            name = request.POST.get('name')
            email = request.POST.get('email')
            phone = request.POST.get('phone')
            venue = request.POST.get('venue')
            message = request.POST.get('message')
            capacity = request.POST.get('capacity')
            function = request.POST.get('function')
            budget = request.POST.get('budget')
            date = request.POST.get('date')

            # Safe reCAPTCHA
            clientKey = request.POST.get('g-recaptcha-response')
            secretKey = "YOUR_SECRET_KEY"

            captchaData = {
                'secret': secretKey,
                'response': clientKey,
            }

            r = requests.post("https://www.google.com/recaptcha/api/siteverify", data=captchaData)
            response = json.loads(r.text)

            if response.get('success'):
                ContactModel.objects.create(
                    name=name,
                    email=email,
                    phone=phone,
                    venue=venue,
                    date=date,
                    budget=budget,
                    capacity=capacity,
                    message=message
                )

                return redirect('Thanks-page')

        except Exception as e:
            print("CONTACT ERROR:", e)

    # ================= COMMENT FORM =================
    if request.method == 'POST' and form.is_valid():
        try:
            form.instance.post = post

            clientKey = request.POST.get('g-recaptcha-response')
            secretKey = "YOUR_SECRET_KEY"

            captchaData = {
                'secret': secretKey,
                'response': clientKey,
            }

            r = requests.post("https://www.google.com/recaptcha/api/siteverify", data=captchaData)
            response = json.loads(r.text)

            if response.get('success'):
                form.save()
                return redirect('Thanks-page')

        except Exception as e:
            print("COMMENT ERROR:", e)

    # ================= RESPONSE =================
    context = {
        'post': post,
        'categories': category,
        'recent_posts': recent_post,
        'socials': social,
    }

    return render(request, 'front/post-details.html', context)


# def post_detailsview(request, slug):
#     if request.method=='POST':
#         name=request.POST['name']
#         email=request.POST['email']
#         phone = request.POST['phone']
#         venue=request.POST['venue']
#         message = request.POST['message']
#         capacity =request.POST['capacity']
#         function = request.POST['function']
#         budget = request.POST['budget']
#         func = FunctionModel.objects.all()
#         date = request.POST['date']
#         clientKey = request.POST['g-recaptcha-response']
#         secretKey="6Lcnwp8hAAAAAFNda3ZsfwMzDsVOsLU5yMBoZpa0"
#         captchaData={
#             'secret':secretKey,
#             'response':clientKey,
#         }
#         r = requests.post(" https://www.google.com/recaptcha/api/siteverify",data=captchaData)
#         response=json.loads(r.text)
#         verify= response['success']
        
#         user=ContactModel.objects.create(name=name,email=email,phone=phone,venue=venue,date=date,budget=budget,capacity=capacity,message=message)
#         user.save()
#         return redirect('Thanks-page')
#     post = Post.objects.get(slug=slug)
#     category = BlogCategoryModel.objects.all().order_by('name')
#     social = SocialMedia.objects.all()
#     recent_post = Post.objects.filter(is_draft=False).order_by('-publish')[:3]
#     form = BlogCommentForm(request.POST or None)
#     if request.method == "POST":
#         if form.is_valid():
#             form.instance.post = post
#             clientKey = request.POST['g-recaptcha-response']
#             secretKey="6Ldt97gkAAAAAGnJu4-A2zXgVyTDKiyMRW5VuJRL"
#             captchaData={
#             'secret':secretKey,
#             'response':clientKey,
#             }
#             r = requests.post(" https://www.google.com/recaptcha/api/siteverify",data=captchaData)
#             response=json.loads(r.text)
#             verify= response['success']
        
#             form.save()
#             return redirect('Thanks-page')
#             messages.success(request,'Successfully Submitted')
            

#     context = {
#         'post': post,
#         'categories': category,
#         'recent_posts': recent_post,
#         'socials' : social,
#         # 'funcs':func,
#     }
#     return render(request, 'front/post-details.html', context)


def post_by_category(request, ctg_name):
    if request.method=='POST':
        name=request.POST['name']
        email=request.POST['email']
        phone = request.POST['phone']
        venue=request.POST['venue']
        message = request.POST['message']
        capacity =request.POST['capacity']
        function = request.POST['function']
        budget = request.POST['budget']
        func = FunctionModel.objects.all()
        date = request.POST['date']
        clientKey = request.POST['g-recaptcha-response']
        secretKey="6Lcnwp8hAAAAAFNda3ZsfwMzDsVOsLU5yMBoZpa0"
        captchaData={
            'secret':secretKey,
            'response':clientKey,
        }
        r = requests.post(" https://www.google.com/recaptcha/api/siteverify",data=captchaData)
        response=json.loads(r.text)
        verify= response['success']
        
        user=ContactModel.objects.create(name=name,email=email,phone=phone,venue=venue,date=date,budget=budget,capacity=capacity,message=message)
        user.save()
    ctg = BlogCategoryModel.objects.get(name=ctg_name)
    post = Post.objects.filter(category=ctg)
    category = BlogCategoryModel.objects.all().order_by('name')
    social = SocialMedia.objects.all()
    recent_post = Post.objects.filter(is_draft=False).order_by('-publish')[:3]
    context = {
        'posts': post,
        'categories': category,
        'recent_posts': recent_post,
        'socials' : social,
        'ctgs' : ctg,
       
    }
    return render(request, 'front/post-by-category.html', context)

class LoginView(TemplateView):

    def post(self,request):
        if request.method=='POST':
            username = request.POST['username']
            password = request.POST['password']

            user = authenticate(username = username,password=password)
            if user.is_staff:
                login(request,user)
                return HttpResponseRedirect('/adminindex')
        else:
            template_name = 'adminpanel_login.html'  
            
            
########################################################  ADMIN DASHBOARD ###############################################
@login_required(login_url='menuApp:adminpanel_login')
def Adminindex(request):
    return render(request,'adminfront/adminindex.html')


class Add_Blog(LoginRequiredMixin,CreateView):
    model = Post
    template_name = 'adminfront/add_blog.html'
    fields = '__all__'
    success_url = reverse_lazy('menuApp:add_blog')
    login_url = '/adminpanel_login/'
    redirect_field_name = 'redirect_to'

class Add_Menubyfunction(LoginRequiredMixin,CreateView):
    model = AddFunctionModel
    template_name = 'adminfront/add_menu_by_function.html'
    form_class = MenuForm
    login_url = '/adminpanel_login/'
    redirect_field_name = 'redirect_to'
    success_url = reverse_lazy('menuApp:list_menubyfunction') 
    def get_context_data(self, **kwargs):
        data = super(Add_Menubyfunction, self).get_context_data(**kwargs)
        if self.request.POST and self.request.FILES:
            data['gallery_image'] = CollectionTitleFormSet4(self.request.POST,self.request.FILES, instance=self.object)
        else:
            data['gallery_image'] = CollectionTitleFormSet4()
        return data

    def form_valid(self, form):
        context = self.get_context_data()
        gallery_image = context['gallery_image']
        with transaction.atomic():
            form.instance.created_by = self.request.user
            self.object = form.save()
            if gallery_image.is_valid():
                gallery_image.instance = self.object
                gallery_image.save()
        return super(Add_Menubyfunction, self).form_valid(form)

    



class Add_Category(LoginRequiredMixin,CreateView):
    model = BlogCategoryModel
    template_name = 'adminfront/add_category.html'
    fields = '__all__'
    login_url = '/adminpanel_login/'
    redirect_field_name = 'redirect_to'
    success_url = reverse_lazy('menuApp:add_category') 

class Add_Element_category(LoginRequiredMixin,CreateView):
    model = Elements_Of_Menu
    template_name = 'adminfront/cat_element.html'
    fields = '__all__'
    login_url = '/adminpanel_login/'
    redirect_field_name = 'redirect_to'
    success_url = reverse_lazy('menuApp:cat_element') 

class Add_Author(LoginRequiredMixin,CreateView):
    model = AuthorProfile
    template_name = 'adminfront/add_author.html'
    fields = '__all__'
    login_url = '/adminpanel_login/'
    redirect_field_name = 'redirect_to'
    success_url = reverse_lazy('menuApp:add_author') 
    
class Add_GalleryCategory(LoginRequiredMixin,CreateView):
    model = Gallery_Category
    template_name = 'adminfront/gallery_category.html'
    fields = '__all__'
    login_url = '/adminpanel_login/'
    redirect_field_name = 'redirect_to'
    success_url = reverse_lazy('menuApp:gallery_category') 

class Add_Clientvenue(LoginRequiredMixin,CreateView):
    model = Venue
    template_name = 'adminfront/add_clientvenue.html'
    fields = '__all__'
    login_url = '/adminpanel_login/'
    redirect_field_name = 'redirect_to'
    success_url = reverse_lazy('menuApp:list_clientvenue') 
    

class Add_Testimonial(LoginRequiredMixin,CreateView,ListView):
    model = Testimonial
    template_name = 'adminfront/add_testimonial.html'
    fields = '__all__'
    context_object_name = 'posts'
    login_url = '/adminpanel_login/'
    redirect_field_name = 'redirect_to'
    success_url = reverse_lazy('menuApp:add_testimonial')
    
class Add_Bloggallery(LoginRequiredMixin,CreateView,ListView):
    model = Bloggallery
    template_name = 'adminfront/blog_images.html'
    fields = '__all__'
    context_object_name = 'posts'
    login_url = '/adminpanel_login/'
    redirect_field_name = 'redirect_to'
    success_url = reverse_lazy('menuApp:blog_images')


class Add_Youtube(LoginRequiredMixin,CreateView,ListView):
    model = Youtube_Testimonial
    template_name = 'adminfront/add_youtube.html'
    fields = '__all__'
    context_object_name = 'posts'
    login_url = '/adminpanel_login/'
    redirect_field_name = 'redirect_to'
    success_url = reverse_lazy('menuApp:add_youtube') 


class Add_CTA(LoginRequiredMixin,CreateView,ListView):
    model = CTA
    template_name = 'adminfront/add_cta.html'
    fields = '__all__'
    context_object_name = 'posts'
    login_url = '/adminpanel_login/'
    redirect_field_name = 'redirect_to'
    success_url = reverse_lazy('menuApp:add_cta') 


class Add_Gallery(LoginRequiredMixin,CreateView):
    model = Gallery
    template_name = 'adminfront/add_gallery.html'
    fields = '__all__'
    login_url = '/adminpanel_login/'
    redirect_field_name = 'redirect_to'
    success_url = reverse_lazy('menuApp:add_gallery') 



class Add_Corporatebrand(LoginRequiredMixin,CreateView,ListView):
    model = Corporate
    template_name = 'adminfront/add_corporatebrand.html'
    fields = '__all__'
    context_object_name = 'stu'
    login_url = '/adminpanel_login/'
    redirect_field_name = 'redirect_to'
    success_url = reverse_lazy('menuApp:add_corporatebrand') 


class Add_Goverment(LoginRequiredMixin,CreateView,ListView):
    model = Goverment_Organization
    template_name = 'adminfront/add_government.html'
    fields = '__all__'
    context_object_name = 'stu'
    login_url = '/adminpanel_login/'
    redirect_field_name = 'redirect_to'
    success_url = reverse_lazy('menuApp:add_government') 

class Add_Cuisine(CreateView):
    model = Cuisine
    template_name = 'adminfront/add_cuisine.html'
    form_class = CuisineForm
    success_url = None
    
    def get_context_data(self, **kwargs):
        data = super(Add_Cuisine, self).get_context_data(**kwargs)
        if self.request.POST and self.request.FILES:
            data['gallery_image'] = CollectionTitleFormSet2(self.request.POST,self.request.FILES, instance=self.object)
        
        else:
            data['gallery_image'] = CollectionTitleFormSet2()
        return data

    def form_valid(self, form):
        context = self.get_context_data()
        gallery_image = context['gallery_image']
        with transaction.atomic():
            form.instance.created_by = self.request.user
            self.object = form.save()
            if gallery_image.is_valid():
                gallery_image.instance = self.object
                gallery_image.save()
        return super(Add_Cuisine, self).form_valid(form)

    def get_success_url(self):
        return reverse_lazy('menuApp:add_cuisine', kwargs={'pk': self.object.pk})


class Add_Culture(LoginRequiredMixin,CreateView):
    model = Culture
    template_name = 'adminfront/add_culture.html'
    form_class = CultureForm
    login_url = '/adminpanel_login/'
    redirect_field_name = 'redirect_to'
    success_url = reverse_lazy('menuApp:list_culture') 
    
    
    def get_context_data(self, **kwargs):
        data = super(Add_Culture, self).get_context_data(**kwargs)
        if self.request.POST and self.request.FILES:
            data['gallery_image'] = CollectionTitleFormSet3(self.request.POST,self.request.FILES, instance=self.object)
        else:
            data['gallery_image'] = CollectionTitleFormSet3()
        return data

    def form_valid(self, form):
        context = self.get_context_data()
        gallery_image = context['gallery_image']
        with transaction.atomic():
            form.instance.created_by = self.request.user
            self.object = form.save()
            if gallery_image.is_valid():
                gallery_image.instance = self.object
                gallery_image.save()
        return super(Add_Culture, self).form_valid(form)

class  Add_Occasion(LoginRequiredMixin,CreateView):
    model = myOccasion
    template_name = 'adminfront/add_occasion.html'
    form_class = OccasionForm
    login_url = '/adminpanel_login/'
    redirect_field_name = 'redirect_to'
    success_url = reverse_lazy('menuApp:list_occasion')  


    def get_context_data(self, **kwargs):
        data = super(Add_Occasion, self).get_context_data(**kwargs)
        if self.request.POST and self.request.FILES:
            data['gallery_image'] = CollectionTitleFormSet1(self.request.POST,self.request.FILES, instance=self.object)
        else:
            data['gallery_image'] = CollectionTitleFormSet1()
        return data

    def form_valid(self, form):
        context = self.get_context_data()
        gallery_image = context['gallery_image']
        with transaction.atomic():
            form.instance.created_by = self.request.user
            self.object = form.save()
            if gallery_image.is_valid():
                gallery_image.instance = self.object
                gallery_image.save()
        return super(Add_Occasion, self).form_valid(form)

    
   



class Add_Portfolio(LoginRequiredMixin,CreateView):
    model = Portfolio
    template_name = 'adminfront/add_portfolio.html'
    fields = '__all__' 
    login_url = '/adminpanel_login/'
    redirect_field_name = 'redirect_to'
    success_url = reverse_lazy('menuApp:list_portfolio')  

class Add_Usp(LoginRequiredMixin,CreateView,ListView):
    model = USP
    template_name = 'adminfront/add_usp.html'
    fields = '__all__' 
    login_url = '/adminpanel_login/'
    redirect_field_name = 'redirect_to'
    context_object_name = 'posts'
    success_url = reverse_lazy('menuApp:add_usp')  

class Add_Homecontent(LoginRequiredMixin,CreateView,ListView):
    model = Homecontent
    template_name = 'adminfront/add_homecontent.html'
    fields = '__all__'
    login_url = '/adminpanel_login/'
    redirect_field_name = 'redirect_to'
    context_object_name = 'posts'
    success_url = reverse_lazy('menuApp:add_homecontent')

class Add_Elementmenu(LoginRequiredMixin,CreateView):
    model = Add_Elements
    template_name = 'adminfront/add_elementmenu.html'
    form_class = ElementForm
    login_url = '/adminpanel_login/'
    redirect_field_name = 'redirect_to'
    success_url = reverse_lazy('menuApp:list_elementmenu')
    
    def get_context_data(self, **kwargs):
        data = super(Add_Elementmenu, self).get_context_data(**kwargs)
        if self.request.POST:
            data['gallery_image'] = CollectionTitleFormSet7(self.request.POST,self.request.FILES, instance=self.object)
        else:
            data['gallery_image'] = CollectionTitleFormSet7()
        return data

    def form_valid(self, form):
        context = self.get_context_data()
        gallery_image = context['gallery_image']
        with transaction.atomic():
            form.instance.created_by = self.request.user
            self.object = form.save()
            if gallery_image.is_valid():
                gallery_image.instance = self.object
                gallery_image.save()
        return super(Add_Elementmenu, self).form_valid(form)

    
 


class Add_Slider(LoginRequiredMixin,CreateView):
    model = Slider
    template_name = 'adminfront/add_slider.html'
    fields = '__all__'
    login_url = '/adminpanel_login/'
    redirect_field_name = 'redirect_to'
    success_url = reverse_lazy('menuApp:list_slider') 

class Add_About(LoginRequiredMixin,CreateView):
    model = Aboutus
    template_name = 'adminfront/add_about.html'
    fields = '__all__'
    login_url = '/adminpanel_login/'
    redirect_field_name = 'redirect_to'
    success_url = reverse_lazy('menuApp:list_about') 
    

class Add_Socialmedia(LoginRequiredMixin,CreateView):
    model = SocialMedia
    template_name = 'adminfront/add_socialmedia.html'
    fields = '__all__'
    login_url = '/adminpanel_login/'
    redirect_field_name = 'redirect_to'
    success_url = reverse_lazy('menuApp:add_socialmedia') 



class Add_Image(LoginRequiredMixin,CreateView):
    # model = Gallery
    template_name = 'adminfront/add_image.html'
    fields = '__all__'
    login_url = '/adminpanel_login/'
    redirect_field_name = 'redirect_to'



class Add_Function(LoginRequiredMixin,CreateView):
    model = FunctionModel
    template_name = 'adminfront/add_function.html'
    form_class = FuncForm
    login_url = '/adminpanel_login/'
    redirect_field_name = 'redirect_to'
    success_url = reverse_lazy('menuApp:list_function') 

    def get_context_data(self, **kwargs):
        data = super(Add_Function, self).get_context_data(**kwargs)
        if self.request.POST and self.request.FILES:
            data['gallery_image'] = CollectionTitleFormSet5(self.request.POST,self.request.FILES, instance=self.object)
            data['faq'] = CollectionTitleFormSet6(self.request.POST,self.request.FILES, instance=self.object)

        else:
            data['gallery_image'] = CollectionTitleFormSet5()
            data['faq'] = CollectionTitleFormSet6()

        return data

    def form_valid(self, form):
        context = self.get_context_data()
        gallery_image = context['gallery_image']
        faq = context['faq']

        with transaction.atomic():
            form.instance.created_by = self.request.user
            self.object = form.save()
            if gallery_image.is_valid() and faq.is_valid():
                gallery_image.instance = self.object
                gallery_image.save()
                faq.instance = self.object
                faq.save()

        return super(Add_Function, self).form_valid(form)

class Edit_Slider(LoginRequiredMixin,UpdateView):
    model = Slider
    template_name = 'adminfront/edit_slider.html'
    fields = '__all__'
    pk_url_kwarg = 'pk'
    login_url = '/adminpanel_login/'
    redirect_field_name = 'redirect_to'
    success_url = reverse_lazy('menuApp:add_slider')

class Edit_CTA(LoginRequiredMixin,UpdateView):
    model = CTA
    template_name = 'adminfront/edit_cta.html'
    fields = '__all__'
    pk_url_kwarg = 'pk'
    login_url = '/adminpanel_login/'
    redirect_field_name = 'redirect_to'
    success_url = reverse_lazy('menuApp:add_cta')

# class Edit_Menubyfunction(LoginRequiredMixin,UpdateView):
#     model = AddFunctionModel
#     template_name = 'adminfront/edit_menubyfunction.html'
#     form_class = MenuForm
#     login_url = '/adminpanel_login/'
#     redirect_field_name = 'redirect_to'
#     success_url = reverse_lazy('menuApp:list_menubyfunction') 
#     def get_context_data(self, **kwargs):
#         data = super(Edit_Menubyfunction, self).get_context_data(**kwargs)
#         if self.request.POST and self.request.FILES:
#             data['gallery_image'] = CollectionTitleFormSet4(self.request.POST,self.request.FILES, instance=self.object)
#         else:
#             data['gallery_image'] = CollectionTitleFormSet4()
#         return data

#     def form_valid(self, form):
#         context = self.get_context_data()
#         gallery_image = context['gallery_image']
#         with transaction.atomic():
#             form.instance.created_by = self.request.user
#             self.object = form.save()
#             if gallery_image.is_valid():
#                 gallery_image.instance = self.object
#                 gallery_image.save()
#         return super(Edit_Menubyfunction, self).form_valid(form)



class Edit_Menubyfunction(LoginRequiredMixin,UpdateView):
    model = MenuByFunctionModel
    template_name = 'adminfront/edit_menubyfunction.html'
    fields = '__all__'
    pk_url_kwarg = 'pk'
    login_url = '/adminpanel_login/'
    redirect_field_name = 'redirect_to'
    success_url = reverse_lazy('menuApp:list_menubyfunction')

class Edit_Occasion(LoginRequiredMixin,UpdateView):
    model = myOccasion
    template_name = 'adminfront/edit_occasion.html'
    form_class = OccasionForm
    success_url = reverse_lazy('menuApp:add_occasion')
    
    def get_context_data(self, **kwargs):
        data = super(Edit_Occasion, self).get_context_data(**kwargs)
        if self.request.POST:
            data['gallery_image'] = CollectionTitleFormSet1(self.request.POST,self.request.FILES, instance=self.object)
        else:
            data['gallery_image'] = CollectionTitleFormSet1(instance=self.object)
        return data

    def form_valid(self, form):
        context = self.get_context_data()
        gallery_image = context['gallery_image']
        with transaction.atomic():
            form.instance.created_by = self.request.user
            self.object = form.save()
            if gallery_image.is_valid():
                gallery_image.instance = self.object
                gallery_image.save()
        return super(Edit_Occasion, self).form_valid(form)

    
    

class Edit_Portfolio(LoginRequiredMixin,UpdateView):
    model = Portfolio
    template_name = 'adminfront/edit_portfolio.html'
    fields = '__all__'
    pk_url_kwarg = 'pk'
    login_url = '/adminpanel_login/'
    redirect_field_name = 'redirect_to'
    success_url = reverse_lazy('menuApp:add_portfolio')

class Edit_Homecontent(LoginRequiredMixin,UpdateView):
    model = Homecontent
    template_name = 'adminfront/edit_homecontent.html'
    fields = '__all__'
    pk_url_kwarg = 'pk'
    login_url = '/adminpanel_login/'
    redirect_field_name = 'redirect_to'
    success_url = reverse_lazy('menuApp:add_homecontent')

class Edit_Elementmenu(LoginRequiredMixin,UpdateView):
    model = Add_Elements
    template_name = 'adminfront/edit_elementmenu.html'
    form_class = ElementForm
    login_url = '/adminpanel_login/'
    redirect_field_name = 'redirect_to'
    success_url = reverse_lazy('menuApp:list_elementmenu')

    def get_context_data(self, **kwargs):
        data = super(Edit_Elementmenu, self).get_context_data(**kwargs)
        if self.request.POST:
            data['gallery_image'] = CollectionTitleFormSet7(self.request.POST,self.request.FILES, instance=self.object)
        else:
            data['gallery_image'] = CollectionTitleFormSet7(instance=self.object)
        return data

    def form_valid(self, form):
        context = self.get_context_data()
        gallery_image = context['gallery_image']
        with transaction.atomic():
            form.instance.created_by = self.request.user
            self.object = form.save()
            if gallery_image.is_valid():
                gallery_image.instance = self.object
                gallery_image.save()
        return super(Edit_Elementmenu, self).form_valid(form)


class Edit_Usp(LoginRequiredMixin,UpdateView):
    model = USP
    template_name = 'adminfront/edit_usp.html'
    fields = '__all__'
    pk_url_kwarg = 'pk'
    login_url = '/adminpanel_login/'
    redirect_field_name = 'redirect_to'
    success_url = reverse_lazy('menuApp:add_usp')  


class Edit_Clientvenue(LoginRequiredMixin,UpdateView):
    model = Venue
    template_name = 'adminfront/edit_clientvenue.html'
    fields = '__all__'
    pk_url_kwarg = 'pk'
    login_url = '/adminpanel_login/'
    redirect_field_name = 'redirect_to'
    success_url = reverse_lazy('menuApp:add_clientvenue')  

class Edit_Blog(LoginRequiredMixin,UpdateView):
    model = Post
    template_name = 'adminfront/edit_blog.html'
    fields = '__all__'
    pk_url_kwarg = 'pk'
    login_url = '/adminpanel_login/'
    redirect_field_name = 'redirect_to'
    success_url = reverse_lazy('menuApp:add_blog')


class Edit_Function(LoginRequiredMixin,UpdateView):
    model = FunctionModel
    template_name = 'adminfront/edit_function.html'
    form_class = FuncForm
    login_url = '/adminpanel_login/'
    redirect_field_name = 'redirect_to'
    success_url = reverse_lazy('menuApp:list_function')
    
    def get_context_data(self, **kwargs):
        data = super(Edit_Function, self).get_context_data(**kwargs)
        if self.request.POST and self.request.FILES:
            data['gallery_image'] = CollectionTitleFormSet5(self.request.POST,self.request.FILES, instance=self.object)
            data['faq'] = CollectionTitleFormSet6(self.request.POST,self.request.FILES, instance=self.object)

        else:
            data['gallery_image'] = CollectionTitleFormSet5()
            data['faq'] = CollectionTitleFormSet6()

        return data

    def form_valid(self, form):
        context = self.get_context_data()
        gallery_image = context['gallery_image']
        faq = context['faq']

        with transaction.atomic():
            form.instance.created_by = self.request.user
            self.object = form.save()
            if gallery_image.is_valid() and faq.is_valid():
                gallery_image.instance = self.object
                gallery_image.save()
                faq.instance = self.object
                faq.save()

        return super(Edit_Function, self).form_valid(form)


class Edit_Imagetest(LoginRequiredMixin,UpdateView):
    model = Testimonial
    template_name = 'adminfront/edit_imagetest.html'
    fields = '__all__'
    pk_url_kwarg = 'pk'
    login_url = '/adminpanel_login/'
    redirect_field_name = 'redirect_to'
    success_url = reverse_lazy('menuApp:add_testimonial') 

class Edit_Imageblog(LoginRequiredMixin,UpdateView):
    model = Bloggallery
    template_name = 'adminfront/edit_imageblog.html'
    fields = '__all__'
    pk_url_kwarg = 'pk'
    login_url = '/adminpanel_login/'
    redirect_field_name = 'redirect_to'
    success_url = reverse_lazy('menuApp:blog_images') 





class Edit_Youtubetest(LoginRequiredMixin,UpdateView):
    model = Youtube_Testimonial
    template_name = 'adminfront/edit_youtubetest.html'
    fields = '__all__'
    pk_url_kwarg = 'pk'
    login_url = '/adminpanel_login/'
    redirect_field_name = 'redirect_to'
    success_url = reverse_lazy('menuApp:add_youtube') 

class Edit_About(LoginRequiredMixin,UpdateView):
    model = Aboutus
    template_name = 'adminfront/edit_about.html'
    fields = '__all__'                               
    pk_url_kwarg = 'pk'
    login_url = '/adminpanel_login/'
    redirect_field_name = 'redirect_to'
    success_url = reverse_lazy('menuApp:add_about')





class Edit_Corporatebrand(LoginRequiredMixin,UpdateView):
    model = Corporate
    template_name = 'adminfront/edit_corporatebrand.html'
    fields = '__all__'
    pk_url_kwarg = 'pk'
    login_url = '/adminpanel_login/'
    redirect_field_name = 'redirect_to'
    success_url = reverse_lazy('menuApp:add_corporatebrand') 

class Edit_Cuisine(LoginRequiredMixin,UpdateView):
    model = Cuisine
    template_name = 'adminfront/edit_cuisine.html'
    login_url = '/adminpanel_login/'
    redirect_field_name = 'redirect_to'
    form_class = CuisineForm
    success_url = reverse_lazy('menuApp:list_cuisine')
    
    
    def get_context_data(self, **kwargs):
        data = super(Edit_Cuisine, self).get_context_data(**kwargs)
        if self.request.POST:
            data['gallery_image'] = CollectionTitleFormSet2(self.request.POST, self.request.FILES, instance=self.object)
        else:
            data['gallery_image'] = CollectionTitleFormSet2(instance=self.object)
        return data

    def form_valid(self, form):
        context = self.get_context_data()
        gallery_image = context['gallery_image']
        with transaction.atomic():
            form.instance.created_by = self.request.user
            self.object = form.save()
            if gallery_image.is_valid():
                gallery_image.instance = self.object
                gallery_image.save()
        return super(Edit_Cuisine, self).form_valid(form)

    

class Edit_Culture(LoginRequiredMixin,UpdateView):
    model = Culture
    template_name = 'adminfront/edit_culture.html'
    login_url = '/adminpanel_login/'
    form_class = CultureForm
    redirect_field_name = 'redirect_to'
    success_url = reverse_lazy('menuApp:add_culture') 
    
    def get_context_data(self, **kwargs):
        data = super(Edit_Culture, self).get_context_data(**kwargs)
        if self.request.POST:
            data['gallery_image'] = CollectionTitleFormSet3(self.request.POST, self.request.FILES, instance=self.object)
        else:
            data['gallery_image'] = CollectionTitleFormSet3(instance=self.object)
        return data

    def form_valid(self, form):
        context = self.get_context_data()
        gallery_image = context['gallery_image']
        with transaction.atomic():
            form.instance.created_by = self.request.user
            self.object = form.save()
            if gallery_image.is_valid():
                gallery_image.instance = self.object
                gallery_image.save()
        return super(Edit_Culture, self).form_valid(form)



class Edit_Government(LoginRequiredMixin,UpdateView):
    model = Goverment_Organization
    template_name = 'adminfront/edit_government.html'
    fields = '__all__'
    pk_url_kwarg = 'pk'
    login_url = '/adminpanel_login/'
    redirect_field_name = 'redirect_to'
    success_url = reverse_lazy('menuApp:add_government')

class Edit_Gallery(LoginRequiredMixin,UpdateView):
    model = Gallery
    template_name = 'adminfront/edit_gallery.html'
    fields = '__all__'
    pk_url_kwarg = 'pk'
    login_url = '/adminpanel_login/'
    redirect_field_name = 'redirect_to'
    success_url = reverse_lazy('menuApp:add_gallery') 


    
@login_required(login_url='menuApp:adminpanel_login')
def List_Blog(request):
    stud = Post.objects.all()
    return render(request, 'adminfront/list_blog.html',{'stu':stud})


@login_required(login_url='menuApp:adminpanel_login')
def List_About(request):
    stud = Aboutus.objects.all()
    return render(request, 'adminfront/list_about.html',{'stu':stud})


@login_required(login_url='menuApp:adminpanel_login')
def List_Menubyfunction(request):
    stud = MenuByFunctionModel.objects.all()
    return render(request, 'adminfront/list_menubyfunction.html',{'stu':stud})




@login_required(login_url='menuApp:adminpanel_login')
def List_Elementmenu(request):
    stud = Add_Elements.objects.all()
    return render(request, 'adminfront/list_elementmenu.html',{'stu':stud})


@login_required(login_url='menuApp:adminpanel_login')
def List_Testimonial(request):
    stud = Testimonial.objects.all()
    return render(request, 'adminfront/list_testimonial.html',{'stu':stud})




@login_required(login_url='menuApp:adminpanel_login')
def List_Function(request):
    stud = FunctionModel.objects.all()
    return render(request, 'adminfront/list_function.html',{'stu':stud})



@login_required(login_url='menuApp:adminpanel_login')
def List_fun_Gallery(request):
    stud = myfuncgallery.objects.all()
    return render(request, 'adminfront/list_function_gallery.html',{'stu':stud})
    
class Edit_fun_gal(LoginRequiredMixin,UpdateView):
    model = myfuncgallery
    template_name = 'adminfront/edit_function_gallery.html'
    fields = '__all__'
    pk_url_kwarg = 'pk'
    login_url = '/adminpanel_login/'
    redirect_field_name = 'redirect_to'
    success_url = reverse_lazy('menuApp:list_function_gallery')

@login_required(login_url='menuApp:adminpanel_login')
def List_faq(request):
    stud = Faqmodel.objects.all()
    return render(request, 'adminfront/list_faq.html',{'stu':stud})
    
class Edit_faq(LoginRequiredMixin,UpdateView):
    model = Faqmodel
    template_name = 'adminfront/edit_faq.html'
    fields = '__all__'
    pk_url_kwarg = 'pk'
    login_url = '/adminpanel_login/'
    redirect_field_name = 'redirect_to'
    success_url = reverse_lazy('menuApp:list_faq')

@login_required(login_url='menuApp:adminpanel_login')
def List_Category(request):
    stud = Category.objects.all()
    return render(request, 'adminfront/list_category.html',{'stu':stud})




@login_required(login_url='menuApp:adminpanel_login')
def List_Clientvenue(request):
    stud = Venue.objects.all()
    return render(request, 'adminfront/list_clientvenue.html',{'stu':stud})



@login_required(login_url='menuApp:adminpanel_login')
def List_Corporate(request):
    stud = Corporate.objects.all()
    return render(request, 'adminfront/list_corporatebrand.html',{'stu':stud})




@login_required(login_url='menuApp:adminpanel_login')
def List_Government(request):
    stud = Goverment_Organization.objects.all()
    return render(request, 'adminfront/list_government.html',{'stu':stud})




@login_required(login_url='menuApp:adminpanel_login')
def List_Comment(request):
    stud = ContactModel.objects.all()
    return render(request, 'adminfront/list_comment.html',{'stu':stud})



@login_required(login_url='menuApp:adminpanel_login')
def Aboutlist(request):                          
    stud = Aboutus.objects.all()
    return render(request, 'adminfront/list_about.html',{'stu':stud})



@login_required(login_url='menuApp:adminpanel_login')
def List_Contact(request):                          
    stud = ContactModel.objects.all()
    return render(request, 'adminfront/list_contact.html',{'stu':stud})



@login_required(login_url='menuApp:adminpanel_login')
def List_Cuisine(request):
    stud = Cuisine.objects.all()
    return render(request, 'adminfront/list_cuisine.html',{'stu':stud})


@login_required(login_url='menuApp:adminpanel_login')
def List_Culture(request):
    stud = Culture.objects.all()
    return render(request, 'adminfront/list_culture.html',{'stu':stud})


@login_required(login_url='menuApp:adminpanel_login')
def List_Occasion(request):
    stud = myOccasion.objects.all()
    return render(request, 'adminfront/list_occasion.html',{'stu':stud})



@login_required(login_url='menuApp:adminpanel_login')
def List_Portfolio(request):
    stud = Portfolio.objects.all()
    return render(request, 'adminfront/list_portfolio.html',{'stu':stud})



@login_required(login_url='menuApp:adminpanel_login')
def List_Gallery(request):
    stud = Gallery.objects.all()
    return render(request, 'adminfront/list_gallery.html',{'stu':stud})



@login_required(login_url='menuApp:adminpanel_login')
def List_Slider(request):
    stud = Slider.objects.all()
    return render(request, 'adminfront/list_slider.html',{'stu':stud})



def Deleteslider(request,id):
    if request.method == "POST":
        pi = Slider.objects.get(pk=id)
        pi.delete()
        return redirect('menuApp:list_slider')
        
def Deletefaq(request,id):
    if request.method == "POST":
        pi = Faqmodel.objects.get(pk=id)
        pi.delete()
        return redirect('menuApp:list_faq')

def Deletefungal(request,id):
    if request.method == "POST":
        pi = myfuncgallery.objects.get(pk=id)
        pi.delete()
        return redirect('menuApp:list_function_gallery')

def Deletegovernment(request,id):
    if request.method == "POST":
        pi = Goverment_Organization.objects.get(pk=id)
        pi.delete()
        return redirect('menuApp:list_government')

def Deleteoccasion(request,id):
    if request.method == "POST":
        pi = myOccasion.objects.get(pk=id)
        pi.delete()
        return redirect('menuApp:list_occasion')

def Deleteabout(request,id):
    if request.method == "POST":
        pi = Aboutus.objects.get(pk=id)
        pi.delete()
        return redirect('menuApp:list_about')

def Deleteimgtest(request,id):
    if request.method == "POST":
        pi = Testimonial.objects.get(pk=id)
        pi.delete()
        return redirect('menuApp:add_testimonial')

def Deleteimgblog(request,id):
    if request.method == "POST":
        pi = Bloggallery.objects.get(pk=id)
        pi.delete()
        return redirect('menuApp:blog_images')



def Deletefunction(request,id):
    if request.method == "POST":
        pi = FunctionModel.objects.get(pk=id)
        pi.delete()
        return redirect('menuApp:list_function')

def Deleteblog(request,id):
    if request.method == "POST":
        pi = Post.objects.get(pk=id)
        pi.delete()
        return redirect('menuApp:list_blog')

def Deleteportfolio(request,id):
    if request.method == "POST":
        pi = Portfolio.objects.get(pk=id)
        pi.delete()
        return redirect('menuApp:list_portfolio')

def Deletegallery(request,id):
    if request.method == "POST":
        pi = Gallery.objects.get(pk=id)
        pi.delete()
        return redirect('menuApp:list_gallery')

def Deletecuisine(request,id):
    if request.method == "POST":
        pi = Cuisine.objects.get(pk=id)
        pi.delete()
        return redirect('menuApp:list_cuisine')


def Deleteculture(request,id):
    if request.method == "POST":
        pi = Culture.objects.get(pk=id)
        pi.delete()
        return redirect('menuApp:list_culture')

def Deleteyoutubetest(request,id):
    if request.method == "POST":
        pi = Youtube_Testimonial.objects.get(pk=id)
        pi.delete()
        return redirect('menuApp:add_youtube')

def Deleteclientvenue(request,id):
    if request.method == "POST":
        pi = Venue.objects.get(pk=id)
        pi.delete()
        return redirect('menuApp:list_clientvenue')

def Deletecoprate(request,id):
    if request.method == "POST":
        pi = Corporate.objects.get(pk=id)
        pi.delete()
        return redirect('menuApp:list_corporatebrand')

def Deletemenubyfunction(request,id):
    if request.method == "POST":
        pi = AddFunctionModel.objects.get(pk=id)
        pi.delete()
        return redirect('menuApp:list_menubyfunction')

def Deleteelementmenu(request,id):
    if request.method == "POST":
        pi = Add_Elements.objects.get(pk=id)
        pi.delete()
        return redirect('menuApp:list_elementmenu')


def Deletecontact(request,id):
    if request.method == "POST":
        pi = ContactModel.objects.get(pk=id)
        pi.delete()
        return redirect('menuApp:list_contact')


def Admintest(request):
    return render(request, 'adminfront/admintest.html')


def Test(request):
    return render(request,'adminfront/test.html')

def Thanks(request):
    return render(request,'front/Thanks-page.html')

def HomeTest(request):
    slider = Slider.objects.all()
    func = FunctionModel.objects.all()
    menu = Elements_Of_Menu.objects.all()
    ename = Add_Elements.objects.all()
    mname = MenuByFunctionModel.objects.all()
    image = AddFunctionModel.objects.all()
    fname = AddFunctionModel.objects.all()
    usp  = USP.objects.all()
    homecontent = Homecontent.objects.all()
    social = SocialMedia.objects.all()
    post = Post.objects.all()[0:3]
    recent_post = Post.objects.filter(is_draft=False).order_by('-publish')[:3]   

    new ={
     'sliders' : slider,    
     'menus':menu,
     'enames': ename,
     'fnames' : fname ,
     'mnames': mname,
     'posts': post,
     'recent_posts':recent_post,
     'usps' : usp,
     'homecontents':homecontent,
      'socials' : social,
      'funcs':func,
      'images' : image,
      
    }

    return render(request, 'front/hometest.html',new)





def page_not_found_view(request, exception):
    return render(request, 'front/404.html',{})





def TestHome(request):
    if request.method=='POST':
        name=request.POST['name']
        email=request.POST['email']
        phone = request.POST['phone']
        venue=request.POST['venue']
        message = request.POST['message']
        capacity =request.POST['capacity']
        function = request.POST['function']
        budget = request.POST['budget']
        func = FunctionModel.objects.all()
        date = request.POST['date']
        clientKey = request.POST['g-recaptcha-response']
        secretKey="6Lcnwp8hAAAAAFNda3ZsfwMzDsVOsLU5yMBoZpa0"
        captchaData={
            'secret':secretKey,
            'response':clientKey,
        }
        r = requests.post(" https://www.google.com/recaptcha/api/siteverify",data=captchaData)
        response=json.loads(r.text)
        verify= response['success']
        
        user=ContactModel.objects.create(name=name,email=email,phone=phone,venue=venue,date=date,budget=budget,capacity=capacity,message=message)
        user.save()
        html_content = render_to_string("front/email.html")
        text_content = strip_tags(html_content)
        
        email = EmailMultiAlternatives('Thank you for showing interest in GetYourMenu ', text_content , settings.DEFAULT_FROM_EMAIL, [email])
        email.attach_alternative(html_content,"text/html")
        email.send()
        
        messages.info(request,'Successfully Submitted!')
        return redirect('Thanks-page')
        
        
    slider = Slider.objects.all()
    func = FunctionModel.objects.all()
    menu = Elements_Of_Menu.objects.all()
    ename = Add_Elements.objects.all()
    mname = FunctionModel.objects.all()
    image = AddFunctionModel.objects.all()
    fname = AddFunctionModel.objects.all()
    usp  = USP.objects.all()
    homecontent = Homecontent.objects.all()
    social = SocialMedia.objects.all()
    post = Post.objects.all()
    recent_post = Post.objects.filter(is_draft=False).order_by('-publish')[0:3]
    cta = CTA.objects.all() 
    # result = requests["function_name"]
    # f = ListingFilter(request.GET, queryset=AddFunctionModel.objects.all())
    # poo = ListingFilterMenu(request.GET, queryset=MenuByFunctionModel.objects.filter()[0:6])
    # m  = MenuByFunctionModel.objects.filter(title=func)
    m  = MenuByFunctionModel.objects.all()
    
    
    
    new ={
        'sliders' : slider,    
        'menus':menu,
        'enames': ename,
        'fnames' : fname ,
        'mnames': mname,
        'posts': post,
        'recent_posts':recent_post,
        'usps' : usp,
        'homecontents':homecontent,
        'socials' : social,
        'funcs':func,
        'images' : image,
        'ctas' : cta,       
        # 'fs':f,
         'ms' : m,
        # 'poos':poo,
        
    }

    return render(request, 'front/testhome.html',new)






def Newtesting(request):
    return render(request, 'front/newtestpage.html')


# SITE MAP----------------

def sitemap_xml(request):
    site_url = "https://www.getyourmenu.in"
    sitemap_path = "/home/getyourmenu/public_html/prodvenu/getyourmenu/menuApp/templates/sitemap.xml"

    today = date.today().isoformat()
    urls = []

    resolver = get_resolver()

    skip_names = [
        "sitemap",
        "admin:index",
        "login",
        "logout",
    ]

    # Auto static URLs from urls.py
    def collect_urls(patterns):
        for pattern in patterns:
            if isinstance(pattern, URLPattern):
                if pattern.name:
                    route = str(pattern.pattern)

                    # Skip dynamic routes like <slug:slug>, <int:id>
                    if "<" in route or ">" in route:
                        continue

                    if pattern.name in skip_names:
                        continue

                    try:
                        url = reverse(pattern.name)

                        urls.append({
                            "loc": site_url + url,
                            "lastmod": today,
                            "changefreq": "daily",
                            "priority": "0.9",
                        })

                    except Exception:
                        pass

            elif isinstance(pattern, URLResolver):
                collect_urls(pattern.url_patterns)

    collect_urls(resolver.url_patterns)

    # Database dynamic URLs
    try:
        from .models import Blog, Category, Function

        # Blog URLs
        try:
            for blog in Blog.objects.all():
                slug = getattr(blog, "slug", None)

                if slug:
                    urls.append({
                        "loc": site_url + "/blog/{}/".format(slug),
                        "lastmod": today,
                        "changefreq": "daily",
                        "priority": "0.8",
                    })
        except Exception:
            pass

        # Category URLs
        try:
            for category in Category.objects.all():
                slug = getattr(category, "slug", None)

                if slug:
                    urls.append({
                        "loc": site_url + "/category/{}/".format(slug),
                        "lastmod": today,
                        "changefreq": "daily",
                        "priority": "0.8",
                    })
        except Exception:
            pass

        # Function URLs
        try:
            for function_obj in Function.objects.all():
                slug = getattr(function_obj, "slug", None)

                if slug:
                    urls.append({
                        "loc": site_url + "/function/{}/".format(slug),
                        "lastmod": today,
                        "changefreq": "daily",
                        "priority": "0.9",
                    })
        except Exception:
            pass

    except Exception:
        pass

    # Remove duplicate URLs
    unique_urls = []
    seen = set()

    for item in urls:
        if item["loc"] not in seen:
            unique_urls.append(item)
            seen.add(item["loc"])

    # Create XML content
    sitemap_content = '<?xml version="1.0" encoding="UTF-8"?>\n'
    sitemap_content += '<urlset xmlns="http://www.sitemaps.org/schemas/sitemap/0.9">\n'

    for item in unique_urls:
        sitemap_content += "  <url>\n"
        sitemap_content += "    <loc>{}</loc>\n".format(escape(item["loc"]))
        sitemap_content += "    <lastmod>{}</lastmod>\n".format(item["lastmod"])
        sitemap_content += "    <changefreq>{}</changefreq>\n".format(item["changefreq"])
        sitemap_content += "    <priority>{}</priority>\n".format(item["priority"])
        sitemap_content += "  </url>\n"

    sitemap_content += "</urlset>\n"

    # Always overwrite sitemap.xml in templates folder
    try:
        sitemap_folder = os.path.dirname(sitemap_path)

        if not os.path.exists(sitemap_folder):
            os.makedirs(sitemap_folder)

        with open(sitemap_path, "w", encoding="utf-8") as file:
            file.write(sitemap_content)

    except Exception:
        pass

    return HttpResponse(sitemap_content, content_type="application/xml")
























