from django.views.generic.base import View
from auth_apis.models import *
from django.contrib.auth import authenticate, login, logout
from django.shortcuts import render, redirect
from auth_apis.models import User
from django.contrib.auth import get_user_model
from django.http import JsonResponse
from django.http.response import HttpResponse
from . import forms
import random
from django.template.loader import render_to_string
from django.core import mail
from django.contrib import messages
from django.conf import settings
import math, random, pytz, string
from django.contrib.auth.decorators import login_required
from django.utils.decorators import method_decorator
from admin_panel.models import *
from datetime  import datetime
from django.core.paginator import Paginator
from django.db.models import Q
from store_apis.models import *
from passlib.hash import django_pbkdf2_sha256 as handler
from store_apis.functions import *
from django.core.exceptions import PermissionDenied
import ast
from panel_apis.models import *
from admin_panel.functions import uploadTheCategory
from panel_apis.functions import *
from datetime import date
from django.template.loader import get_template
# from TaqnyatSms import client
from .functions import *
from io import BytesIO
from django.http import HttpResponse
from django.template.loader import get_template
from xhtml2pdf import pisa
import pdfkit
from django.template.loader import render_to_string
# import weasyprint
from django.http import HttpResponse
from django.template.loader import get_template
from django.template import Context
import pyqrcode 
from pyqrcode import QRCode 
import codecs
from django.core.mail import EmailMultiAlternatives
from xhtml2pdf import pisa
from django.core.files.storage import default_storage
from django.core.files.storage import FileSystemStorage
import io
# import string_utils
from urllib.request import urlopen 
import base64
import requests
import urllib.request
from PIL import Image
from pyfcm import FCMNotification


bearer = '27d7d01f7fb16de8e22b0b2de5a4a236'

# def my_login_required(function):
#     def wrapper(request, *args, **kw):
#         if not request.session.get('user_id'):
#             return redirect('/store-login')
#         else:
#             return function(request, *args, **kw)
#     return wrapper


def set_invoice_number(user_id):
	todays_date = date.today()
	uid = f"{str(todays_date.year)}0" + str(user_id + (10 ** 2))
	return uid

def checkEmailStore(request):
	text = request.GET.get('email')
	post = User.objects.filter(email=text,is_superuser=0).count()
	if post != 1:
		return HttpResponse ('true')
	else:
		message = 'This email already exist in our database'
		return JsonResponse(message,safe=False)

def checkIfLoginStore(function):
	def  wrap(request, *args, **kwargs):
		loginlink = '/store-login'
		# if request.path!='/store-login/':
		# 	loginlink += '?next=' + request.path
		print("=1=")
		if 'user_id' in request.session:
			userId=request.session['user_id']
			if request.session['user_id']==userId:
				store_obj = Stores.objects.filter(user_id = userId).first()
				if store_obj:
					if request.path=='/store-login':
						return redirect('/store-dashboard')
				else:
					if request.path!='/store-login':
						return redirect(loginlink)
		else:
			print("=3=")
			if request.path!='/store-login/':
				return redirect(loginlink)
		return function(request, *args, **kwargs)
	wrap.__doc__ = function.__doc__
	return wrap

# def checkLoginPasswordStore(request):
# 	isd_code = request.GET.get('isd_code','')
# 	phone_number = request.GET.get('phone_number','')
# 	password = request.GET.get('password')
# 	user         = User.objects.filter(end_date__isnull = True,isd_code=isd_code,phone_number=phone_number,is_seller=1).first()
# 	if user.check_password(password) == False:
# 		message = 'Please enter the correct password'
# 		return JsonResponse(message,safe=False)
# 	else:
# 		return HttpResponse ('true')


def store_only(view_func):
	def wrap(request, *args, **kwargs):
		if request.session['user_id']:
			return view_func(request, *args, **kwargs)
		else:
			return render(request, "/store_login")
	return wrap


class storeLoginIn(View):
	def get(self,request):
		return render(request,'store_login.html')
	
	def post(self,request):
		form = forms.store_login(request.POST)
		if form.is_valid():
			password = form.cleaned_data.get('password')
			userObj  = User.objects.filter(isd_code=form.cleaned_data.get('isd_code'),phone_number=form.cleaned_data.get('phone_number'),is_seller=1).first()
			if userObj.status == 0:
				messages.error(request,'Your store has been disabled by admin.Please contact admin.')
				return redirect('/store-login')
			if userObj:
				new_pass = userObj.password
				check = handler.verify(password,new_pass)
				if check:
					request.session['user_id'] = userObj.id
					messages.success(request,'Login Successfully')
					return redirect('/store-dashboard')
				else:
					messages.error(request,'Invalid Credentials')
					return redirect('/store-login')
			else:
				messages.error(request,'User not exist')
				return redirect('/store-login')
		else:
			return render(request,'store_login.html')


class storeDashboard(View):
	@method_decorator(checkIfLoginStore,name="dispatch")
	def get(self,request):
		user_id = User.objects.filter(id=request.session['user_id'],is_seller = 1).first()
		store_obj = Stores.objects.filter(user_id=user_id.id).first()
		store_info = Stores.objects.filter(user_id=request.session['user_id']).first()
		total_products = Products.objects.filter(end_date__isnull = True,store_id=store_info).count()
		total_service_request = ServiceRequests.objects.filter(store=store_info.id).count()
		order_count = 0
		total_earning = 0
		order_obj = orderPack.objects.filter(isPaid=True)
		for order in order_obj:
			if order.productDetail.product.store == store_info:
				order_count += 1
				total_earning += float(order.totalAmount)


		from django.db.models.functions import TruncMonth
		import datetime
		from django.db.models import Sum
		from decimal import Decimal

		current_year = datetime.datetime.now().year

		month_list = ['01' , '02' , '03' , '04' , '05' , '06' , '07' ,'08' , '09' , '10' , '11' , '12']
		order_data = []
		services = []
		for mnth in month_list:
			all_orders = orderPack.objects.filter(isPaid=True,created_at__year=current_year ,created_at__month=mnth).count()
			if order.productDetail.product.store == store_info:
				order_data.append(all_orders)
			all_service = ServiceRequests.objects.filter(store=store_info.id,start_date__year=current_year ,start_date__month=mnth).count()
			services.append(all_service)



		


		if store_obj.is_profile_completed == False:
			messages.error(request,'Please complete the profile first.')
			return redirect('/store-profile',{'store_info':store_info})
		else:
			return render(request,'store_dashboard.html',{'store_info':store_info,'total_products':total_products,'total_service_request':total_service_request,'order_count':order_count,'total_earning':total_earning,'orders':order_data,'services':services})


class storeProfile(View):
	@method_decorator(checkIfLoginStore,name="dispatch")
	def get(self,request):
		user_id = User.objects.filter(id=request.session['user_id'],is_seller = 1).first()
		store_obj = Stores.objects.filter(user_id=user_id.id).first()
		store_info = Stores.objects.filter(user_id=request.session['user_id']).first()
		return render(request,'store_profile.html',{'store_obj':store_obj,'store_info':store_info})

	def post(self,request):
		form = forms.store_profile(request.POST)
		if form.is_valid():
			user_id = User.objects.filter(id=request.session['user_id'],is_seller = 1).first()
			Stores.objects.filter(user_id=user_id.id).update(
				store_name_english = form.cleaned_data.get('store_name_english'),
				store_description_english = form.cleaned_data.get('store_description_english'),
				store_name_arabic = form.cleaned_data.get('store_name_arabic'),
				store_description_arabic = form.cleaned_data.get('store_description_arabic'),
				store_number = form.cleaned_data.get('store_number'),
				store_email = form.cleaned_data.get('store_email'),
				country = form.cleaned_data.get('country'),
				address = form.cleaned_data.get('address'),
				start_date = datetime.now(),
				is_profile_completed = True
			)
			if request.FILES.get('store_logo'):
				fileUrl=uploadTheStoreLogo(request.FILES.get('store_logo'))
				fileUrl=str(settings.BASE_URL)+'/'+fileUrl
				Stores.objects.filter(user_id=user_id.id).update(store_logo=str(fileUrl))
			if request.FILES.get('store_banner'):
				fileUrl=uploadTheStoreLogo(request.FILES.get('store_banner'))
				fileUrl=str(settings.BASE_URL)+'/'+fileUrl
				Stores.objects.filter(user_id=user_id.id).update(store_banner=str(fileUrl))
			messages.success(request,'Store updated successfully')
			return redirect('/store-dashboard')
		else:
			return render(request,'store_profile.html')


class storeLogout(View):
	def get(self,request):
		del request.session['user_id']
		messages.success(request,'Logout Successfully')
		return redirect('/store-login')



class storeResetPassword(View):
	@method_decorator(checkIfLoginStore,name="dispatch")
	def get(self,request):
		store_info = Stores.objects.filter(user_id=request.session['user_id']).first()
		return render(request,'store_reset_password.html',{'store_info':store_info})
	
	def post(self,request):
		form = forms.change_password_form(request.POST)
		if form.is_valid():
			password = request.POST.get("confirmPassword")
			user     = User.objects.get(id=request.session['user_id'])
			user.set_password(password)
			user.save()
			messages.info(request, 'You have successfully reset your password')
			return redirect('/store-dashboard')
		else:
			return render(request,'store_reset_password.html')


def storeCheckPassword(request):
	old_password = request.GET.get('old_password')
	user         = User.objects.get(id=request.session['user_id'])
	if user.check_password(old_password) == False:
		message = 'Does not match with the old password.'
		return JsonResponse(message,safe=False)
	else:
		return HttpResponse ('true')



class storeForgetPassword(View):
	def get(self,request):
		return render(request,'store_forget_password.html')
	def post(self,request):
		form = forms.storeforgetpasswordform(request.POST)
		if form.is_valid():
			request.session['isd_code'] = form.cleaned_data.get('isd_code')
			request.session['phone_number'] = form.cleaned_data.get('phone_number')
			user_check = User.objects.filter(isd_code = form.cleaned_data.get('isd_code'),phone_number = form.cleaned_data.get('phone_number'),is_seller=True).first()
			if user_check:
				theotp=random.randrange(1000, 9999, 5)
				user_check.forgot_password_otp=theotp
				user_check.save()
				# body =body = 'this is small test for the sms service from the beni team.The otp for the resend verification is'+ str(theotp)
				# recipients = [966504378399]
				# #recipients = [form.cleaned_data.get('isd_code').replace("+", "")+form.cleaned_data.get('phone_number')]
				# sender = 'Taqnyat.sa'
				# scheduled=''
				# taqnyt = client(bearer)
				# message = taqnyt.sendMsg(body, recipients, sender,scheduled)
				# print('------------------',message)
				messages.success(request,'OTP send successfully')
				return redirect('/forget-otp-verify')
			else:
				messages.error(request,'No user found')
				return render(request,'store_forget_password.html')    
		else:
			return render(request,'store_forget_password.html')

class resendForgetOtp(View):
	def get(self,request):
		isd_code = request.session['isd_code']
		phone_number = request.session['phone_number']
		user_check = User.objects.filter(isd_code = isd_code,phone_number = phone_number,is_seller=True).first()
		if user_check:
			theotp=random.randrange(1000, 9999, 5)
			user_check.forgot_password_otp=theotp
			user_check.save()
			# body = 'This is small test for the sms service from the beni team.The otp for the resend verification is'+str(theotp)
			# scheduled=''
			# recipients = [966504378399]
			# sender = 'Taqnyat.sa'
			# taqnyt = client(bearer)
			# message = taqnyt.sendMsg(body, recipients, sender,scheduled)
			# print('------------------',message)
			messages.success(request,'OTP resend successfully')
			return redirect('/forget-otp-verify')
		else:
			messages.success(request,'No user found')
			return redirect('/forget-otp-verify')


class forgetOTPverify(View):
	def get(Self,request):
		return render(request,'store_forget_otp.html')
	def post(self,request):
		form = forms.otpforgetform(request.POST)
		if form.is_valid():
			isd_code = request.session['isd_code']
			phone_number = request.session['phone_number']
			otp_one = form.cleaned_data.get('otp_one')
			otp_two = form.cleaned_data.get('otp_two')
			otp_three = form.cleaned_data.get('otp_three')
			otp_four = form.cleaned_data.get('otp_four')
			final_otp = otp_one+otp_two+otp_three+otp_four
			user_obj = User.objects.filter(isd_code=isd_code,phone_number=phone_number).first()
			if int(final_otp) == int(user_obj.forgot_password_otp):
				messages.success(request,'OTP verfied successfully')
				return redirect('/change-forget-password')
			else:
				messages.error(request,'Incorrect OTP')
				return redirect('/forget-otp-verify')
		else:
			return render(request,'store_forget_otp.html')

class changeForgetPassword(View):
	def get(self,request):
		return render(request,'store_change_forget.html')
	def post(self,request):
		form = forms.changeforgetpasswordform(request.POST)
		if form.is_valid():
			isd_code = request.session['isd_code']
			phone_number = request.session['phone_number']
			customerObj=User.objects.filter(isd_code=isd_code,phone_number=phone_number,is_seller=1).first()
			new_password = form.cleaned_data.get('password')
			confirm_password = form.cleaned_data.get('confirm_password')
			if new_password == confirm_password:
				if customerObj:
					customerObj.set_password(new_password)
					customerObj.save()
					messages.success(request,'Password changed successfully')
					return redirect('/store-login')
			else:
				messages.error(request,'Password and confirm password are not same')
				return redirect('/change-forget-password')
		else:
			return render(request,'store_change_forget.html')


class productListingStore(View):
	@method_decorator(checkIfLoginStore,name="dispatch")
	def get(self,request):
		try:
			store_info = Stores.objects.filter(user_id=request.session['user_id']).first()
			data_obj =  Products.objects.filter(end_date__isnull = True,store_id=store_info).order_by('-id')
			search_post = request.GET.get('search')
			if search_post:
				data_obj = Products.objects.filter(Q(product_name_english__icontains=search_post) |Q(product_name_arabic__icontains=search_post)).order_by('-id')
			paginator = Paginator(data_obj, 10)
			page_number = request.GET.get('page')
			service_obj = paginator.get_page(page_number)
			return render(request,'store_product_listing.html',{'product_obj':service_obj,'search_post':search_post,'store_info':store_info})
		except Exception as e:
			print(e)
			return redirect('/product-listing-store')

class addProductStore(View):
	@method_decorator(checkIfLoginStore,name="dispatch")
	def get(self,request):
		try:
			store_info = Stores.objects.filter(user_id=request.session['user_id']).first()
			main_categories = MainCategories.objects.filter(status=1,end_date__isnull =True)
			sub_categories = Subcategories.objects.filter(status=1,end_date__isnull =True)
			brands = Brands.objects.filter(status=1,end_date__isnull =True)
			stones = Stones.objects.filter(status=1,end_date__isnull =True)
			vat_obj = CommissionSection.objects.all().first()
			if vat_obj.vat_percentage:
				vat_value = vat_obj.vat_percentage
			else:
				vat_value = 0.00
			if 'main_id' in request.GET:
				sub_categories = Subcategories.objects.filter(maincategory_id=request.GET.get('main_id'),end_date__isnull =True).all() 
			return render(request,'store_add_product.html',{'main_categories':main_categories,'sub_categories':sub_categories,'brands':brands,'store_info':store_info,'stones':stones,'vat_value':vat_value})
		except Exception as e:
			print(e)
			return redirect('/product-listing-store')

	def post(self,request):
		form = forms.addProduct(request.POST)
		if form.is_valid():
			product_name_english = form.cleaned_data.get('product_name_english')
			product_name_arabic = form.cleaned_data.get('product_name_arabic')
			maincategory = MainCategories.objects.filter(id=form.cleaned_data.get('maincategory')).first()
			subcategory = Subcategories.objects.filter(id=form.cleaned_data.get('subcategory')).first()
			description_english = form.cleaned_data.get('description_english')
			description_arabic = form.cleaned_data.get('description_arabic')
			brand = Brands.objects.filter(id=form.cleaned_data.get('brand')).first()
			size = form.cleaned_data.get('size')
			model_name = form.cleaned_data.get('model_name')
			weight = form.cleaned_data.get('weight')
			color = form.cleaned_data.get('color')
			quantity = form.cleaned_data.get('quantity')
			price = form.cleaned_data.get('price')
			offer_discount = form.cleaned_data.get('price_discount')
			stone_id = form.cleaned_data.get('stone')
			if stone_id:
				stone = Stones.objects.filter(id=stone_id).first()
			else:
				stone = None

			vat_obj = CommissionSection.objects.all().first()
			if vat_obj.vat_percentage:
				vat_value = vat_obj.vat_percentage
			else:
				vat_value = 0.00


			if offer_discount:
				is_offer_applied =  True
				calculate_vat = round(int(offer_discount)/100*int(vat_value))
				round_off_discount = int(offer_discount)+calculate_vat


			else:
				is_offer_applied = False
				round_off_discount = None

			calculate_vat = round( int(price)/100*int(vat_value))
			price =  int(price)+calculate_vat

			store_id = Stores.objects.filter(user_id=request.session['user_id']).first()
			product_obj = Products.objects.create(product_name_english=product_name_english,product_name_arabic=product_name_arabic,maincategory=maincategory,
			subcategory=subcategory,description_english=description_english,description_arabic=description_arabic,brand=brand,size=size,weight=weight,color=color,
			quantity=quantity,price=price,is_offer_applied=is_offer_applied,store_id = store_id.id,model_name=model_name,offer_discount=round_off_discount,price_discount=round_off_discount,stone=stone
			)
			form_data = []
			if request.FILES.getlist('images'):
				images = request.FILES.getlist('images')
				print('images', images)
				for image in images:
					if image.size > 5 * 1024 * 1024:  # Skip if image size is greater than 5 MB
						continue

					fileUrl = uploadTheProductImages(image)
					fileUrl = str(settings.BASE_URL) + '/' + fileUrl
					form_data.append(fileUrl)
				
				product_obj.images = form_data
				product_obj.save()

			messages.success(request,'Product added successfully')
			return redirect('/product-listing-store')
		else:
			return render(request,'store_add_product.html')


class editProductStore(View):
	@method_decorator(checkIfLoginStore,name="dispatch")
	def get(self,request,id):
		store_info = Stores.objects.filter(user_id=request.session['user_id']).first()
		main_categories = MainCategories.objects.filter(status=1,end_date__isnull =True)
		sub_categories = Subcategories.objects.filter(status=1,end_date__isnull =True)
		brands = Brands.objects.filter(status=1,end_date__isnull =True)
		stones = Stones.objects.filter(status=1,end_date__isnull =True)
		if 'main_id' in request.GET:
			sub_categories = Subcategories.objects.filter(maincategory_id=request.GET.get('main_id'),end_date__isnull =True).all() 
		store_obj = Products.objects.filter(id=id).first()
		product_images =  ast.literal_eval(store_obj.images)
		vat_obj = CommissionSection.objects.all().first()
		if vat_obj.vat_percentage:
			vat_value = vat_obj.vat_percentage
		else:
			vat_value = 0.00
		return render(request,'store_edit_product.html',{'main_categories':main_categories,'sub_categories':sub_categories,'brands':brands,'store_obj':store_obj,'product_images':product_images,'store_info':store_info,'stones':stones,'vat_value':vat_value})

	def post(self,request,id):
		form = forms.addProduct(request.POST)
		if form.is_valid():
			product_name_english = form.cleaned_data.get('product_name_english')
			product_name_arabic = form.cleaned_data.get('product_name_arabic')
			maincategory = MainCategories.objects.filter(id=form.cleaned_data.get('maincategory')).first()
			subcategory = Subcategories.objects.filter(id=form.cleaned_data.get('subcategory')).first()
			description_english = form.cleaned_data.get('description_english')
			description_arabic = form.cleaned_data.get('description_arabic')
			brand = Brands.objects.filter(id=form.cleaned_data.get('brand')).first()
			size = form.cleaned_data.get('size')
			model_name = form.cleaned_data.get('model_name')
			weight = form.cleaned_data.get('weight')
			color = form.cleaned_data.get('color')
			quantity = form.cleaned_data.get('quantity')
			price = form.cleaned_data.get('price')
			offer_discount = form.cleaned_data.get('price_discount')
			stone_id = form.cleaned_data.get('stone')
			if stone_id:
				stone = Stones.objects.filter(id=stone_id).first()
			else:
				stone = None
			

			vat_obj = CommissionSection.objects.all().first()
			if vat_obj.vat_percentage:
				vat_value = vat_obj.vat_percentage
			else:
				vat_value = 0.00


			if offer_discount:
				is_offer_applied =  True
				calculate_vat = round(int(offer_discount)/100*int(vat_value))
				round_off_discount = int(offer_discount)+calculate_vat


			else:
				is_offer_applied = False
				round_off_discount = None

			calculate_vat = round( int(price)/100*int(vat_value))
			price =  int(price)+calculate_vat


			store_id = Stores.objects.filter(user_id=request.session['user_id']).first()
			product_obj = Products.objects.filter(id=id).update(product_name_english=product_name_english,product_name_arabic=product_name_arabic,maincategory=maincategory,
			subcategory=subcategory,description_english=description_english,description_arabic=description_arabic,brand=brand,size=size,weight=weight,color=color,
			quantity=quantity,price=price,price_discount=round_off_discount,store_id = store_id.id,model_name=model_name,is_offer_applied=is_offer_applied,offer_discount=round_off_discount,stone=stone
			)
			product_obj_image = Products.objects.filter(id=id).first()
			product_images =  ast.literal_eval(product_obj_image.images)

			form_data = []
			for img in product_images:
				form_data.append(img)
			if request.FILES.getlist('images'):
				images = request.FILES.getlist('images')
				print('images',images)
				for image in images:
					if image.size > 5 * 1024 * 1024:  # Skip if image size is greater than 5 MB
						continue
					fileUrl=uploadTheProductImages(image)
					fileUrl=str(settings.BASE_URL)+'/'+fileUrl
					form_data.append(fileUrl)
				Products.objects.filter(id=id).update(images=form_data)
			messages.success(request,'Product added successfully')
			return redirect('/product-listing-store')
		else:
			return render(request,'store_add_product.html')

class removeImageProduct(View):
	@method_decorator(checkIfLoginStore,name="dispatch")
	def get(self,request):
		print(request.GET.get('file_name'))
		print(request.GET.get('product_id'))
		if 'product_id' in request.GET:
			product_obj_image = Products.objects.filter(id=request.GET.get('product_id')).first()
			product_images =  ast.literal_eval(product_obj_image.images)
			form_data = []
			y = request.GET.get('file_name').replace("'","")
			print(y)
			for img in product_images:
				if str(img) != y:
					print(img)
					form_data.append(img)
			print(form_data)
			Products.objects.filter(id=request.GET.get('product_id')).update(images=form_data)
			return HttpResponse('success')


class changeProductStatus(View):
	def post(self,request):
		pub        = Products.objects.get(id = request.POST['main_id'])
		pub.status = request.POST['status']
		pub.save()
		if pub.status == "1":
			messages.success(request, "Product is activated")
			return HttpResponse(request.META.get('HTTP_REFERER'))
		else:
			messages.error(request, "Product is deactivated")
			return HttpResponse(request.META.get('HTTP_REFERER'))



class deleteProduct(View):
	@method_decorator(checkIfLoginStore,name="dispatch")
	def get(self,request,id):
		Products.objects.filter(id=id).update(end_date=datetime.now())
		messages.success(request, "Deleted successfully")
		return redirect('/product-listing-store')


class viewProduct(View):
	@method_decorator(checkIfLoginStore,name="dispatch")
	def get(self,request,id):
		try:
			store_info = Stores.objects.filter(user_id=request.session['user_id']).first()
			product_obj = Products.objects.filter(id=id).first()
			product_images =  ast.literal_eval(product_obj.images)
			return render(request,'store_view_product.html',{'product_obj':product_obj,'product_images':product_images,'store_info':store_info})
		except Exception as e:
			print(e)
			return redirect('/product-listing-store')

class addStoreService(View):
	@method_decorator(checkIfLoginStore,name="dispatch")
	def get(self,request):
		store_info = Stores.objects.filter(user_id=request.session['user_id']).first()
		service_obj = Services.objects.filter(status=True,end_date__isnull = True)
		print('service_obj',service_obj)
		return render(request,'add_store_service.html',{'service':service_obj,'store_info':store_info})
	def post(self,request):
		store_info = Stores.objects.filter(user_id=request.session['user_id']).first()
		form = forms.storeServiceForm(request.POST)
		if form.is_valid():
			service_id = Services.objects.filter(id=form.cleaned_data.get('service_id')).first()
			check_existing = storeServices.objects.filter(store_id=store_info.id,serviceId_id=service_id.id)
			if not check_existing:
				data_obj =  storeServices.objects.create(store_id=store_info.id,serviceId_id=service_id.id)
				messages.success(request,'Service added successfully')
			else:
				messages.warning(request,'This service is already added')
			return redirect('/store-service-listing')
		else:
			return render(request,'add_store_service.html',{'form':form})

class storeServiceListing(View):
	@method_decorator(checkIfLoginStore,name="dispatch")
	def get(self,request):
		store_info = Stores.objects.filter(user_id=request.session['user_id']).first()
		data_obj =  storeServices.objects.filter(end_date__isnull = True,store_id=store_info)
		search_post = request.GET.get('search')
		if search_post:
			data_obj =  storeServices.objects.filter(Q(serviceId__english_service_name__icontains=search_post),end_date__isnull = True,store_id=store_info)
		paginator = Paginator(data_obj, 10)
		page_number = request.GET.get('page')
		order_obj = paginator.get_page(page_number)
		return render(request,'store_service_listing.html',{'data_obj':order_obj,'store_info':store_info,'search_post':search_post})

class changeStoreServiceStatus(View):
	@method_decorator(checkIfLoginStore,name="dispatch")
	def post(self,request):
		store_info = Stores.objects.filter(user_id=request.session['user_id']).first()
		pub        = storeServices.objects.filter(store=store_info,id = request.POST['main_id']).first()
		pub.status = request.POST['status']
		pub.save()
		if pub.status == "1":
			messages.success(request, "Service status is activated")
			return HttpResponse(request.META.get('HTTP_REFERER'))
		else:
			messages.error(request, "Service status is deactivated")
			return HttpResponse(request.META.get('HTTP_REFERER'))
		

class addServiceModel(View):
	@method_decorator(checkIfLoginStore,name="dispatch")
	def get(self,request):
		store_info = Stores.objects.filter(user_id=request.session['user_id']).first()
		return render(request,'add_service_model.html',{'store_info':store_info})
	def post(self,request):
		store_info = Stores.objects.filter(user_id=request.session['user_id']).first()
		form = forms.storeServiceModelForm(request.POST)
		if form.is_valid():
			service_model_english = form.cleaned_data.get('service_model_english')
			service_model_arabic = form.cleaned_data.get('service_model_arabic')
			check_existing = ServiceModel.objects.filter(store_id=store_info.id,service_model_english=service_model_english)
			if not check_existing:
				data_obj =  ServiceModel.objects.create(store_id=store_info.id,service_model_english=service_model_english,service_model_arabic=service_model_arabic)
				messages.success(request,'Model added successfully')
			else:
				messages.success(request,'Model already added')
			return redirect('/service-model-listing')
		else:
			return render(request,'add_service_model.html',{'form':form})

class editServiceModel(View):
	@method_decorator(checkIfLoginStore,name="dispatch")
	def get(self,request,id):
		store_info = Stores.objects.filter(user_id=request.session['user_id']).first()
		serviceModel_obj = ServiceModel.objects.filter(id=id).first()
		return render(request,'edit_service_model.html',{'service_obj':serviceModel_obj,'store_info':store_info})

	def post(self,request,id):
		form = forms.storeServiceModelForm(request.POST)
		if form.is_valid():
			service_model_english = form.cleaned_data.get('service_model_english')
			service_model_arabic = form.cleaned_data.get('service_model_arabic')
			serviceModel_obj = ServiceModel.objects.filter(id=id).update(service_model_english=service_model_english,service_model_arabic=service_model_arabic)
		
			messages.success(request,'Model updated successfully')
			return redirect('/service-model-listing')
		else:
			return render(request,'edit_service_model.html')


class serviceModelListing(View):
	@method_decorator(checkIfLoginStore,name="dispatch")
	def get(self,request):
		store_info = Stores.objects.filter(user_id=request.session['user_id']).first()
		data_obj =  ServiceModel.objects.filter(end_date__isnull = True,store_id=store_info)
		search_post = request.GET.get('search')
		if search_post:
			data_obj =  ServiceModel.objects.filter(Q(service_model_english__icontains=search_post) | Q(service_model_arabic__icontains=search_post),end_date__isnull = True,store_id=store_info)
		paginator = Paginator(data_obj, 10)
		page_number = request.GET.get('page')
		order_obj = paginator.get_page(page_number)
		return render(request,'service_model_listing.html',{'data_obj':order_obj,'store_info':store_info,'search_post':search_post})

class changeServiceModelStatus(View):
	@method_decorator(checkIfLoginStore,name="dispatch")
	def post(self,request):
		store_info = Stores.objects.filter(user_id=request.session['user_id']).first()
		pub        = ServiceModel.objects.filter(store=store_info,id = request.POST['main_id']).first()
		pub.status = request.POST['status']
		pub.save()
		if pub.status == "1":
			messages.success(request, "Model status is activated")
			return HttpResponse(request.META.get('HTTP_REFERER'))
		else:
			messages.error(request, "Model status is deactivated")
			return HttpResponse(request.META.get('HTTP_REFERER'))

class deleteServiceModel(View):
	@method_decorator(checkIfLoginStore,name="dispatch")
	def get(self,request,id):
		ServiceModel.objects.filter(id=id).update(end_date=datetime.now())
		messages.success(request, "Deleted successfully")
		return redirect('/service-model-listing')

class addStoneType(View):
	@method_decorator(checkIfLoginStore,name="dispatch")
	def get(self,request):
		store_info = Stores.objects.filter(user_id=request.session['user_id']).first()
		return render(request,'add_stone_type.html',{'store_info':store_info})
	def post(self,request):
		store_info = Stores.objects.filter(user_id=request.session['user_id']).first()
		form = forms.storeStoneTypeForm(request.POST)
		if form.is_valid():
			stone_type_english = form.cleaned_data.get('stone_type_english')
			stone_type_arabic = form.cleaned_data.get('stone_type_arabic')
			check_existing = StoneType.objects.filter(store_id=store_info.id,stone_type_english=stone_type_english)
			if not check_existing:
				data_obj =  StoneType.objects.create(store_id=store_info.id,stone_type_english=stone_type_english,stone_type_arabic=stone_type_arabic)
				messages.success(request,'Stone added successfully')
			else:
				messages.success(request,'Stone already added')
			return redirect('/stone-type-listing')
		else:
			return render(request,'add_stone_type.html',{'form':form})

class editStoneType(View):
	@method_decorator(checkIfLoginStore,name="dispatch")
	def get(self,request,id):
		store_info = Stores.objects.filter(user_id=request.session['user_id']).first()
		serviceModel_obj = StoneType.objects.filter(id=id).first()
		return render(request,'edit_stone_type.html',{'service_obj':serviceModel_obj,'store_info':store_info})

	def post(self,request,id):
		form = forms.storeStoneTypeForm(request.POST)
		if form.is_valid():
			stone_type_english = form.cleaned_data.get('stone_type_english')
			stone_type_arabic = form.cleaned_data.get('stone_type_arabic')
			serviceModel_obj = StoneType.objects.filter(id=id).update(stone_type_english=stone_type_english,stone_type_arabic=stone_type_arabic)
		
			messages.success(request,'Stone updated successfully')
			return redirect('/stone-type-listing')
		else:
			return render(request,'edit_stone_type.html')

class stoneTypeListing(View):
	@method_decorator(checkIfLoginStore,name="dispatch")
	def get(self,request):
		store_info = Stores.objects.filter(user_id=request.session['user_id']).first()
		data_obj =  StoneType.objects.filter(end_date__isnull = True,store_id=store_info)
		print('data_obj',data_obj)
		search_post = request.GET.get('search')
		if search_post:
			data_obj =  StoneType.objects.filter(Q(stone_type_english__icontains=search_post) | Q(stone_type_arabic__icontains=search_post),end_date__isnull = True,store_id=store_info)
		paginator = Paginator(data_obj, 10)
		page_number = request.GET.get('page')
		order_obj = paginator.get_page(page_number)
		return render(request,'stone_type_listing.html',{'data_obj':order_obj,'store_info':store_info,'search_post':search_post})

class changeStoneTypeStatus(View):
	@method_decorator(checkIfLoginStore,name="dispatch")
	def post(self,request):
		store_info = Stores.objects.filter(user_id=request.session['user_id']).first()
		pub        = StoneType.objects.filter(store=store_info,id = request.POST['main_id']).first()
		pub.status = request.POST['status']
		pub.save()
		if pub.status == "1":
			messages.success(request, "Stone status is activated")
			return HttpResponse(request.META.get('HTTP_REFERER'))
		else:
			messages.error(request, "Stone status is deactivated")
			return HttpResponse(request.META.get('HTTP_REFERER'))

class deleteStoneType(View):
	@method_decorator(checkIfLoginStore,name="dispatch")
	def get(self,request,id):
		StoneType.objects.filter(id=id).update(end_date=datetime.now())
		messages.success(request, "Deleted successfully")
		return redirect('/stone-type-listing')
	
class addServiceType(View):
	@method_decorator(checkIfLoginStore,name="dispatch")
	def get(self,request):
		store_info = Stores.objects.filter(user_id=request.session['user_id']).first()
		return render(request,'add_service_type.html',{'store_info':store_info})
	def post(self,request):
		store_info = Stores.objects.filter(user_id=request.session['user_id']).first()
		form = forms.storeServiceTypeForm(request.POST)
		if form.is_valid():
			service_type_english = form.cleaned_data.get('service_type_english')
			service_type_arabic = form.cleaned_data.get('service_type_arabic')
			check_existing = ServiceType.objects.filter(store_id=store_info.id,service_type_english=service_type_english)
			if not check_existing:
				data_obj =  ServiceType.objects.create(store_id=store_info.id,service_type_english=service_type_english,service_type_arabic=service_type_arabic)
				messages.success(request,'Service added successfully')
			else:
				messages.warning(request,'This service is already added')
			return redirect('/service-type-listing')
		else:
			return render(request,'add_service_type.html',{'form':form})

class editServiceType(View):
	@method_decorator(checkIfLoginStore,name="dispatch")
	def get(self,request,id):
		store_info = Stores.objects.filter(user_id=request.session['user_id']).first()
		serviceModel_obj = ServiceType.objects.filter(id=id).first()
		return render(request,'edit_service_type.html',{'service_obj':serviceModel_obj,'store_info':store_info})

	def post(self,request,id):
		form = forms.storeServiceTypeForm(request.POST)
		if form.is_valid():
			service_type_english = form.cleaned_data.get('service_type_english')
			service_type_arabic = form.cleaned_data.get('service_type_arabic')
			serviceModel_obj = ServiceType.objects.filter(id=id).update(service_type_english=service_type_english,service_type_arabic=service_type_arabic)
		
			messages.success(request,'Service updated successfully')
			return redirect('/service-type-listing')
		else:
			return render(request,'edit_service_type.html')

class serviceTypeListing(View):
	@method_decorator(checkIfLoginStore,name="dispatch")
	def get(self,request):
		store_info = Stores.objects.filter(user_id=request.session['user_id']).first()
		data_obj =  ServiceType.objects.filter(end_date__isnull = True,store_id=store_info)
		print('data_obj',data_obj)
		search_post = request.GET.get('search')
		if search_post:
			data_obj =  ServiceType.objects.filter(Q(service_type_english__icontains=search_post) | Q(service_type_arabic__icontains=search_post),end_date__isnull = True,store_id=store_info)
		paginator = Paginator(data_obj, 10)
		page_number = request.GET.get('page')
		order_obj = paginator.get_page(page_number)
		return render(request,'service_type_listing.html',{'data_obj':order_obj,'store_info':store_info,'search_post':search_post})

class changeServiceTypeStatus(View):
	@method_decorator(checkIfLoginStore,name="dispatch")
	def post(self,request):
		store_info = Stores.objects.filter(user_id=request.session['user_id']).first()
		pub        = ServiceType.objects.filter(store=store_info,id = request.POST['main_id']).first()
		pub.status = request.POST['status']
		pub.save()
		if pub.status == "1":
			messages.success(request, "Service status is activated")
			return HttpResponse(request.META.get('HTTP_REFERER'))
		else:
			messages.error(request, "Service status is deactivated")
			return HttpResponse(request.META.get('HTTP_REFERER'))

class deleteServiceType(View):
	@method_decorator(checkIfLoginStore,name="dispatch")
	def get(self,request,id):
		ServiceType.objects.filter(id=id).update(end_date=datetime.now())
		messages.success(request, "Deleted successfully")
		return redirect('/service-type-listing')

class orderListing(View):
	@method_decorator(checkIfLoginStore,name="dispatch")
	def get(self,request):
		try:
			allData = []
			store_info = Stores.objects.filter(user_id=request.session['user_id']).first()
			print('store_info',store_info)
			order_obj = orderPack.objects.filter(isPaid=True).order_by('-id')
			search_start = request.GET.get('start_date')
			search_end = request.GET.get('end_date')
			time = "11:59:59"
			print('time',time)
			lookups = Q()
			if search_start and search_end:
				print('dateser')
				lookups.add(Q(created_at__range=[search_start, search_end + ' '+ time]), Q.AND)
				order_obj = orderPack.objects.filter(lookups).order_by('-id')
				print('datesearch',order_obj)
			search_post = request.GET.get('search')
			if search_post:
				print('search')
				order_obj = orderPack.objects.filter(Q(orderId__icontains=search_post)).order_by('-id')
			for order in order_obj:
				print('order.productDetail.product.store',order.productDetail.product.store)
				if order.productDetail.product.store == store_info:
					allData.append(order)
			paginator = Paginator(allData, 10)
			page_number = request.GET.get('page')
			order_obj = paginator.get_page(page_number)
			vat_value = CommissionSection.objects.all().first()
			return render(request,'store_order_listing.html',{'all_order':order_obj,'store_info':store_info,'search_post':search_post,'search_start':search_start,'search_end':search_end,'vat_value':vat_value.vat_percentage})     
		except Exception as e:
			print(e)
			return redirect('/store-dashboard')

class boxTypeLisiting(View):
	@method_decorator(checkIfLoginStore,name="dispatch")
	def get(self,request):
		store_info = Stores.objects.filter(user_id=request.session['user_id']).first()
		data_obj =  GiftBoxType.objects.filter(end_date__isnull = True,store_id=store_info)
		print('data_obj',data_obj)
		search_post = request.GET.get('search')
		if search_post:
			data_obj =  GiftBoxType.objects.filter(Q(box_name_english__icontains=search_post) |Q(box_name_arabic__icontains=search_post) ,end_date__isnull = True,store_id=store_info)
		paginator = Paginator(data_obj, 10)
		page_number = request.GET.get('page')
		order_obj = paginator.get_page(page_number)
		return render(request,'box_type_listing.html',{'data_obj':order_obj,'store_info':store_info,'search_post':search_post})

class addBoxType(View):
	@method_decorator(checkIfLoginStore,name="dispatch")
	def get(self,request):
		store_info = Stores.objects.filter(user_id=request.session['user_id']).first()
		return render(request,'add_box_type.html',{'store_info':store_info})
	def post(self,request):
		store_info = Stores.objects.filter(user_id=request.session['user_id']).first()
		form = forms.storeGiftBoxTypeForm(request.POST)
		if form.is_valid():
			box_name_english = form.cleaned_data.get('box_name_english')
			box_name_arabic = form.cleaned_data.get('box_name_arabic')
			box_cost = form.cleaned_data.get('box_cost')
			check_existing = GiftBoxType.objects.filter(store_id=store_info.id,box_name_english=box_name_english)
			if not check_existing:
				data_obj =  GiftBoxType.objects.create(store_id=store_info.id,box_name_english=box_name_english,box_name_arabic=box_name_arabic,box_cost=box_cost)
				if request.FILES.get('box_icon'):
					fileUrl=uploadTheCategory(request.FILES.get('box_icon'))
					fileUrl=str(settings.BASE_URL)+'/'+fileUrl
					data_obj.box_image=str(fileUrl)
					data_obj.save()
				messages.success(request,'Box added successfully')
			else:
				messages.success(request,'Box already added')
			return redirect('/box-type-listing')
		else:
			return render(request,'add_box_type.html',{'form':form})

class editBoxType(View):
	@method_decorator(checkIfLoginStore,name="dispatch")
	def get(self,request,id):
		store_info = Stores.objects.filter(user_id=request.session['user_id']).first()
		main_obj = GiftBoxType.objects.filter(id=id).first()
		return render(request,'edit_box_type.html',{'main_obj':main_obj,'store_info':store_info})

	def post(self,request,id):
		form = forms.storeGiftBoxTypeForm(request.POST)
		if form.is_valid():
			GiftBoxType.objects.filter(id=id).update(  
				box_name_english=form.cleaned_data.get('box_name_english'),
				box_name_arabic=form.cleaned_data.get('box_name_arabic'),
				box_cost=form.cleaned_data.get('box_cost')
			)
			if request.FILES.get('box_icon'):
				fileUrl=uploadTheCategory(request.FILES.get('box_icon'))
				fileUrl=str(settings.BASE_URL)+'/'+fileUrl
				GiftBoxType.objects.filter(id=id).update(box_image=str(fileUrl)) 
			messages.success(request,'Box updated successfully')
			return redirect('/box-type-listing')
		else:
			return render(request,'edit_box_type.html',{'form':form})

class changeGiftBoxStatus(View):
	@method_decorator(checkIfLoginStore,name="dispatch")
	def post(self,request):
		store_info = Stores.objects.filter(user_id=request.session['user_id']).first()
		pub        = GiftBoxType.objects.filter(store=store_info,id = request.POST['main_id']).first()
		pub.status = request.POST['status']
		pub.save()
		if pub.status == "1":
			messages.success(request, "Box status is activated")
			return HttpResponse(request.META.get('HTTP_REFERER'))
		else:
			messages.error(request, "Box status is deactivated")
			return HttpResponse(request.META.get('HTTP_REFERER'))

class deleteGiftBox(View):
	@method_decorator(checkIfLoginStore,name="dispatch")
	def get(self,request,id):
		GiftBoxType.objects.filter(id=id).update(end_date=datetime.now())
		messages.success(request, "Deleted successfully")
		return redirect('/box-type-listing')

class giftPackagingList(View):
	@method_decorator(checkIfLoginStore,name="dispatch")
	def get(self,request):
		store_info = Stores.objects.filter(user_id=request.session['user_id']).first()
		data_obj =  GiftPackingType.objects.filter(end_date__isnull = True,store_id=store_info)
		print('data_obj',data_obj)
		search_post = request.GET.get('search')
		if search_post:
			data_obj =  GiftPackingType.objects.filter(Q(packaging_name_english__icontains=search_post) |Q(packaging_name_arabic__icontains=search_post) ,end_date__isnull = True,store_id=store_info)
		paginator = Paginator(data_obj, 10)
		page_number = request.GET.get('page')
		order_obj = paginator.get_page(page_number)
		return render(request,'gift_packaging_list.html',{'data_obj':order_obj,'store_info':store_info,'search_post':search_post})

class addGiftPackaging(View):
	@method_decorator(checkIfLoginStore,name="dispatch")
	def get(self,request):
		store_info = Stores.objects.filter(user_id=request.session['user_id']).first()
		return render(request,'add_gift_packaging.html',{'store_info':store_info})
	def post(self,request):
		store_info = Stores.objects.filter(user_id=request.session['user_id']).first()
		form = forms.storeGiftPackingForm(request.POST)
		if form.is_valid():
			packaging_name_english = form.cleaned_data.get('packaging_name_english')
			packaging_name_arabic = form.cleaned_data.get('packaging_name_arabic')
			packaging_cost = form.cleaned_data.get('packaging_cost')
			check_existing = GiftPackingType.objects.filter(store_id=store_info.id,packaging_name_english=packaging_name_english)
			if not check_existing:
				data_obj =  GiftPackingType.objects.create(store_id=store_info.id,packaging_name_english=packaging_name_english,packaging_name_arabic=packaging_name_arabic,packaging_cost=packaging_cost)
				if request.FILES.get('box_icon'):
					fileUrl=uploadTheCategory(request.FILES.get('box_icon'))
					fileUrl=str(settings.BASE_URL)+'/'+fileUrl
					data_obj.packaging_image=str(fileUrl)
					data_obj.save()
				messages.success(request,'Packaging added successfully')
			else:
				messages.success(request,'Packaging already added')
			return redirect('/gift-packaging-list')
		else:
			return render(request,'add_gift_packaging.html',{'form':form})
		

class editGiftPackaging(View):
	@method_decorator(checkIfLoginStore,name="dispatch")
	def get(self,request,id):
		store_info = Stores.objects.filter(user_id=request.session['user_id']).first()
		main_obj = GiftPackingType.objects.filter(id=id).first()
		return render(request,'edit_gift_packaging.html',{'main_obj':main_obj,'store_info':store_info})
	
	def post(self,request,id):
		form = forms.storeGiftPackingForm(request.POST)
		if form.is_valid():
			GiftPackingType.objects.filter(id=id).update(  
				packaging_name_english=form.cleaned_data.get('packaging_name_english'),
				packaging_name_arabic=form.cleaned_data.get('packaging_name_arabic'),
				packaging_cost=form.cleaned_data.get('packaging_cost')
			)
			if request.FILES.get('box_icon'):
				fileUrl=uploadTheCategory(request.FILES.get('box_icon'))
				fileUrl=str(settings.BASE_URL)+'/'+fileUrl
				GiftPackingType.objects.filter(id=id).update(packaging_image=str(fileUrl)) 
			messages.success(request,'Box updated successfully')
			return redirect('/gift-packaging-list')
		else:
			return render(request,'edit_gift_packaging.html',{'form':form})

class changeGiftPackagingStatus(View):
	@method_decorator(checkIfLoginStore,name="dispatch")
	def post(self,request):
		store_info = Stores.objects.filter(user_id=request.session['user_id']).first()
		pub        = GiftPackingType.objects.filter(store=store_info,id = request.POST['main_id']).first()
		pub.status = request.POST['status']
		pub.save()
		if pub.status == "1":
			messages.success(request, "Packaging status is activated")
			return HttpResponse(request.META.get('HTTP_REFERER'))
		else:
			messages.error(request, "Packaging status is deactivated")
			return HttpResponse(request.META.get('HTTP_REFERER'))
class deleteGiftPackaging(View):
	@method_decorator(checkIfLoginStore,name="dispatch")
	def get(self,request,id):
		GiftPackingType.objects.filter(id=id).update(end_date=datetime.now())
		messages.success(request, "Deleted successfully")
		return redirect('/gift-packaging-list')

class getStoreNotifications(View):
	@method_decorator(checkIfLoginStore,name="dispatch")
	def get(self,request):
		store_info = Stores.objects.filter(user_id=request.session['user_id']).first()
		not_obj = StoreNotifications.objects.filter(end_date__isnull = True,store_id=store_info.id).order_by('-id')
		search_start = request.GET.get('start_date')
		time = datetime.now().strftime('%H:%M:%S')
		search_end = request.GET.get('end_date') 
		if search_start:
			not_obj = StoreNotifications.objects.filter(start_date__range=[search_start, search_end + ' '+ time],end_date__isnull=True).order_by('-id')
		paginator = Paginator(not_obj, 10)
		page_number = request.GET.get('page')
		notify_obj = paginator.get_page(page_number)
		return render(request,'get_store_notifications.html',{"notify_obj":notify_obj,'search_start':search_start,'search_end':search_end,'store_info':store_info})

class deleteStoreNotifications(View):
	@method_decorator(checkIfLoginStore,name="dispatch")
	def get(self,request):
		store_info = Stores.objects.filter(user_id=request.session['user_id']).first()
		ids = request.GET.get('delete_id')
		if ids:
			int_id_list = [int(id) for id in ids.split(',')]
			StoreNotifications.objects.filter(pk__in=int_id_list).delete()
			messages.success(request,"Deleted Sucessfully")
		else:
			messages.error(request,"At least One notification must be selected")
		return redirect('/get-store-notifications')

class readNotificationStore(View):
	@method_decorator(checkIfLoginStore,name="dispatch")
	def get(self,request):
		store_info = Stores.objects.filter(user_id=request.session['user_id']).first()
		not_obj = StoreNotifications.objects.filter(store_id=store_info.id).last()
		not_obj.is_read = False
		not_obj.save()
		return redirect('/get-store-notifications') 



class serviceRequestList(View):
	@method_decorator(checkIfLoginStore,name="dispatch")
	def get(self,request):
		store_info = Stores.objects.filter(user_id=request.session['user_id']).first()
		data_obj = ServiceRequests.objects.filter(store=store_info.id).order_by('-id')
		search_post = request.GET.get('search')
		if search_post:
			data_obj =  ServiceRequests.objects.filter(Q(serviceId__english_service_name__icontains=search_post) | Q(customer__first_name__icontains=search_post) | Q(customer__last_name__icontains=search_post),end_date__isnull = True,store_id=store_info)
		paginator = Paginator(data_obj, 10)
		page_number = request.GET.get('page')
		req_obj = paginator.get_page(page_number)
		return render(request,'service_request_list.html',{'req_obj':req_obj,'search_post':search_post,'store_info':store_info})


class changeServiceStatus(View):
	@method_decorator(checkIfLoginStore,name="dispatch")
	def post(self,request,id):
		print('action',request.POST['action'])
		store_info = Stores.objects.filter(user_id=request.session['user_id']).first()
		data_obj = ServiceRequests.objects.filter(id=id,store=store_info.id).first()
		ServiceRequests.objects.filter(id=id).update(delivery_status=request.POST['action'])
		if request.POST['action'] == '0':
			delivery_status = "Pending"
		elif request.POST['action'] == '1':
			delivery_status = "On the way"
		else:
			delivery_status = "Delivered"

		registration_id = data_obj.customer.user.device_token
		server_key = str(settings.FIREBASE_SERVER_KEY)
		if  data_obj.customer.user.notification_enabled == 1:
			if data_obj.customer.user.device_type == 'android':

				data_message = {		'type': 'service_status',
										'title' : 'SERVICE ACCEPTED',
										"message" : 'Your service request delivery for '+ data_obj.serviceId.english_service_name + 'is '+ delivery_status,
									}
				
				result = FCMNotification(api_key=server_key).notify_single_device(registration_id=registration_id,  data_message=data_message)
			if data_obj.customer.user.device_type == 'ios':
				message_title = 'SERVICE STATUS',
				message_body =  'Your service request delivery is '+delivery_status,
				data_message = {		'type': 'service_status',
										'title' : 'SERVICE STATUS',
										"message" :  'Your service request delivery is '+delivery_status,
									}
				result = FCMNotification(api_key=server_key).notify_single_device(registration_id=registration_id, message_title=message_title, 
				message_body=message_body, data_message=data_message)
		buyer_obj = Buyer.objects.filter(id=data_obj.customer.id).first()
		CustomerNotifications.objects.create(customer=buyer_obj,message='Your service request delivery for '+ data_obj.serviceId.english_service_name + ' is '+ delivery_status ,notification_type="Service")
		messages.success(request, "Status changes successfully")
		return HttpResponse(request.META.get('HTTP_REFERER'))



class testFcm(View):
	def get(self,request):
		registration_id = 'cLWvBCEzQHSqmlyM6-LKPM:APA91bFbX2gvrxC3QX6OcSlbZIflOPLS7Cdmpu-Cg6ryZ46Ucw1Uf61kqIHvnvzV-SeNl67Czcr1-EEWFEQCEJHZyRMIg2jbw_jOYnidQVGbBBn_LJIprpYjti8toMv6AX74KsPntlzS'
		server_key = 'AAAAyWeVa0M:APA91bHrD_vt7MqP2_R8PlFNAOsdvKR02IXEVjPhBaXZnUTjw6EmcEM4Vp8RJad8jrypS1geR29rcBvSfGlwX_h4z7VmfQpepemdEcQh8kjSwMNRwLR9FrVyh35HJdjXSckIHMqSErSe'

		data_message = {		'type': 'service_status',
								'title' : 'SERVICE ACCEPTED',
								"message" : 'Your service request delivery for',
							}
		
		result = FCMNotification(api_key=server_key).notify_single_device(registration_id=registration_id,  data_message=data_message)
		print("++++++++++++++++++++",result)
		return JsonResponse({'status_code':200,'status_message':'result','data':result})

class viewServiceRequest(View):
	@method_decorator(checkIfLoginStore,name="dispatch")
	def get(self,request,id):
		store_info = Stores.objects.filter(user_id=request.session['user_id']).first()
		data_obj = ServiceRequests.objects.filter(id=id,store=store_info.id).first()
		return render(request,'view_service_request.html',{'data_obj':data_obj,'store_info':store_info})


class acceptRequestList(View):
	@method_decorator(checkIfLoginStore,name="dispatch")
	def get(self,request,id):
		store_info = Stores.objects.filter(user_id=request.session['user_id']).first()
		data_obj = ServiceRequests.objects.filter(id=id,store=store_info.id).first()
		data_obj.service_status = 1
		data_obj.save()
		html_message = render_to_string('service_approved.html')
		plain_message = html_message
		from_email = settings.EMAIL_HOST_USER
		to = data_obj.customer.user.email
		subject = 'Serivce Accepted'
		print(data_obj.customer.user.email)
		mail.send_mail(subject, plain_message, from_email, [to], html_message=html_message)
		messages.success(request, "Serivce accepted successfully")
		return redirect('/service-request-list')


class rejectRequestList(View):
	@method_decorator(checkIfLoginStore,name="dispatch")
	def get(self,request,id):
		store_info = Stores.objects.filter(user_id=request.session['user_id']).first()
		data_obj = ServiceRequests.objects.filter(id=id,store=store_info.id).first()
		data_obj.service_status = 2
		data_obj.save()
		html_message = render_to_string('service_rejected.html')
		plain_message = html_message
		from_email = settings.EMAIL_HOST_USER
		to = data_obj.customer.user.email
		subject = 'Service Rejected'
		mail.send_mail(subject, plain_message, from_email, [to], html_message=html_message)
		messages.success(request, "Service rejected successfully")

		return redirect('/service-request-list')

# class marketingRequestList(View):
#     def get(self,request):
#         data_obj = MarketingRequest.objects.all()
#         search_post = request.GET.get('search')
#         if search_post:
#             data_obj = MarketingRequest.objects.filter(Q(product_name=search_post)|Q(store_name_arabic__icontains=search_post)|Q(owner_name=search_post),end_date__isnull=True).order_by('-id')
#         paginator = Paginator(data_obj, 8)
#         page_number = request.GET.get('page')
#         req_obj = paginator.get_page(page_number)
#         return render(request,'marketing_request_list.html',{'req_obj':req_obj,'search_post':search_post})


# class marketingRequestDetail(View):
#     def get(self,request,id):
#         req_obj = MarketingRequest.objects.filter(id=id).first()
#         return render(request,'marketing_details.html',{'req_obj':req_obj})


class dealSectionList(View):
	@method_decorator(checkIfLoginStore,name="dispatch")
	def get(self,request):
		store_info = Stores.objects.filter(user_id=request.session['user_id']).first()
		data_obj =  Products.objects.filter(today_deal_start_date__isnull=False,store_id = store_info.id).order_by('-id')
		search_post = request.GET.get('search')
		if search_post:
			data_obj = Products.objects.filter(Q(product_name_english__icontains=search_post) |Q(product_name_arabic__icontains=search_post),today_deal_start_date__isnull=False,store_id = store_info.id).order_by('-id')
		paginator = Paginator(data_obj, 10)
		page_number = request.GET.get('page')
		today_obj = paginator.get_page(page_number)
		return render(request,'deal_section_list.html',{'today_obj':today_obj,'search_post':search_post,'store_info':store_info})



class addDealProduct(View):
	@method_decorator(checkIfLoginStore,name="dispatch")
	def get(self,request):
		store_info = Stores.objects.filter(user_id=request.session['user_id']).first()
		products_obj = Products.objects.filter(is_offer_applied=1,end_date__isnull = True, status=True,store_id = store_info.id)
		return render (request,'add_deal_product.html',{'product_obj':products_obj,'store_info':store_info})

	def post(self,request):
		form = forms.addDealForm(request.POST)
		if form.is_valid():
			product_id = form.cleaned_data.get('product_id')
			Products.objects.filter(id=product_id).update(today_deal_start_date= date.today())
			messages.success(request, "Sepical deal added successfully")
			return redirect('/deal-section-list')
		else:
			return render (request,'add_deal_product.html',{'form':form})

class deleteDealProduct(View):
	@method_decorator(checkIfLoginStore,name="dispatch")
	def get(self,request,id):
		Products.objects.filter(id=id).update(today_deal_start_date= None)
		messages.success(request, "Sepical deal deleted successfully")
		return redirect('/deal-section-list')


class chatList(View):
	@method_decorator(checkIfLoginStore,name="dispatch")
	def get(self,request):
		store_info = Stores.objects.filter(user_id=request.session['user_id']).first()
		user_obj =  User.objects.get(id=store_info.user_id)
		rooms = chat_room.objects.filter(store=user_obj).order_by("-last_message_time")
		buyer_info = Buyer.objects.all()
		todayDate = date.today()
		# for room in rooms:
		# for room in rooms:
		# 	BuyerObj = room.user
		# 	buyer_info = Buyer.objects.filter(user_id=BuyerObj.id).first()
		return render(request,'chat_list.html',{'rooms':rooms,'store_info':store_info,'buyer_info':buyer_info,'today_date':todayDate})
	
from rest_framework.views import APIView
class getMessageList(APIView):
	@method_decorator(checkIfLoginStore,name="dispatch")
	def get(self,request):
		try:
			data = request.query_params
			store_id = data.get('store_id')
			user_id = data.get('user_id')
			if not user_id:
				return JsonResponse({'status_code':400,'status_message':'user_id is required'})
			if not store_id:
				return JsonResponse({'status_code':400,'status_message':'store_id is required'})
			storeChat = User.objects.get(id=store_id)
			chatuser = User.objects.get(id=user_id)
			storeObj = Stores.objects.get(user_id=storeChat.id)
			userObj = Buyer.objects.get(user_id=chatuser.id)
			messages = Message.objects.filter(sender_user=storeChat, receiver_user=chatuser).order_by("created_at") | Message.objects.filter(sender_user=chatuser, receiver_user=storeChat).order_by("created_at")
			allData = []
			for message in messages:
				if message.sender_user == storeChat:
					sender = True
				else:
					sender = False
				print('message.sender_user.id',message.sender_user.id)
				print('message.receiver_user.id',message.receiver_user.id)
				name = Buyer.objects.get(Q(user_id=message.sender_user.id)| Q(user_id=message.receiver_user.id))
				if message.type == "text":
					allData.append({"message": message.message, "sender_name":name.first_name +' '+ name.last_name,"sender":sender,"date": message.created_at,"type": message.type,})
				else:
					allData.append({"message": message.image,"sender_name":name.first_name +' '+ name.last_name, "sender":sender,"date": message.created_at,"type": message.type})
				
			return JsonResponse({'data':allData})

		except Exception as e:
			return JsonResponse({"status_code":'500',"status_message":str(e)})


class addMessages(APIView):
	def post(self,request):
		try:
			data = request.data
			store_id = data.get('store_id')
			user_id = data.get('user_id')
			message = data.get("message")
			if not user_id:
				return JsonResponse({'status_code':400,'status_message':'user_id is required'})
			if not store_id:
				return JsonResponse({'status_code':400,'status_message':'store_id is required'})
			if not message:
				return JsonResponse({'status_code':400,'status_message':'message is required'})
			# storeObj = Stores.objects.get(id=store_id)
			# buyerObj = Buyer.objects.get(id=user_id)
			store = User.objects.get(id=store_id)
			buyer = User.objects.get(id=user_id)
			# message_type = data.get("message_type")
			image = data.get("image")
			# if not message_type:
			# 	return Response({'status_code':status.HTTP_400_BAD_REQUEST,'status_message':'message_type is required'},status=status.HTTP_400_BAD_REQUEST)
			# if message_type == "text":
			if not image:
				Message.objects.create(sender_user=store, receiver_user=buyer, message=message, type="text")
				cr = chat_room.objects.get(user=buyer, store=store)
				cr.last_message_text = message
				cr.last_message_time = datetime.now()
				cr.is_read = 1
				cr.save()
			else:
				fileUrl=uploadThemessagepicture(image)
				fileUrl=str(settings.BASE_URL)+'/'+fileUrl
				image_url=str(fileUrl)
				Message.objects.create(sender_user=store, receiver_user=buyer, image=image_url, type="image")
				cr = chat_room.objects.get(user=buyer, store=store)
				cr.last_message_text = None
				cr.last_message_time = datetime.now()
				cr.is_read = 1
				cr.save()
			return JsonResponse({'message':'success'})
			
		except Exception as e:
			return JsonResponse({"status_code":'500',"status_message":str(e)})



class changeOrderStatus(View):
	@method_decorator(checkIfLoginStore,name="dispatch")
	def post(self,request,id):
		print('action',request.GET.get('action'))
		orderPack.objects.filter(id=id).update(delivery_status=request.POST['action'])
		data_obj = orderPack.objects.filter(id=id).first()

		if request.POST['action'] == '0':
			delivery_status = "Pending"
		elif request.POST['action'] == '1':
			delivery_status = "On the way"
		else:
			delivery_status = "Delivered"

		registration_id = data_obj.customer.device_token
		server_key = str(settings.FIREBASE_SERVER_KEY)
		if data_obj.customer.notification_enabled == 1:
			if data_obj.customer.device_type == 'android':
				data_message = {		'type': 'order_status',
										'title' : 'ORDER STATUS',
										"message" : 'Your order request delivery for '+ data_obj.orderId + ' is '+ delivery_status,
									}
				result = FCMNotification(api_key=server_key).notify_single_device(registration_id=registration_id,  data_message=data_message)
			if data_obj.customer.device_type == 'ios':
				message_title = 'SERVICE ACCEPTED',
				message_body =  'Your order request delivery for '+ data_obj.orderId + ' is '+ delivery_status,
				data_message = {		'type': 'order_status',
										'title' : 'ORDER STATUS',
										"message" : 'Your order request delivery for '+ data_obj.orderId + ' is '+ delivery_status,
									}
				result = FCMNotification(api_key=server_key).notify_single_device(registration_id=registration_id, message_title=message_title, message_body=message_body, data_message=data_message)
		buyer_obj = Buyer.objects.filter(user_id=data_obj.customer.id).first()
		CustomerNotifications.objects.create(customer=buyer_obj,message='Your order request delivery for '+ data_obj.orderId + ' is '+ delivery_status ,notification_type="Service")
		messages.success(request, "Status changes successfully")
		return HttpResponse(request.META.get('HTTP_REFERER'))
	



class getInvoice(View):
	@method_decorator(checkIfLoginStore,name="dispatch")
	def get(self,request,id):
		#getting the template
		invoice = orderPack.objects.filter(id=id).first()
		customer_obj = Buyer.objects.filter(id=invoice.customer_id).first()
		orders_obj = Cart.objects.filter(orderId = invoice.orderId,isPaid = True)
		trans_id = CustomerTransaction.objects.filter(orderPack_id = invoice.id ).first()
		qr_unique_number = str(customer_obj.first_name)[:4]+ str(datetime.now()) + str(invoice.totalAmount)[:4] 
		print("------------------",qr_unique_number)
		new_str = codecs.unicode_escape_decode(string_utils.shuffle(qr_unique_number))[0]
		encodedparceldetails = new_str.encode('utf-16', 'surrogatepass').decode('utf-16')
		url = pyqrcode.create(content=encodedparceldetails)
		import os
		if(os.path.exists(str(settings.BASE_DIR)+'/media/qrCode/')):
			pass
		else:
			os.mkdir(str(settings.BASE_DIR)+'/media/qrCode/')
		url.png(str(settings.BASE_DIR)+"/media/qrCode/"+invoice.orderId+".png", scale = 8)
		image = os.path.join(str(settings.MEDIA_ROOT)+"qrCode/",invoice.orderId+".png")
		print('image',image)
		invoice.qr_code_image=image
		invoice.save()

		path_to_image = "media/" + invoice.qr_code_image

		# Construct the absolute path to the image file
		abs_path_to_image = os.path.join(os.getcwd(), path_to_image)

		# Open the image file using Pillow
		with open(abs_path_to_image, "rb") as image_file:
			encoded_string = base64.b64encode(image_file.read())

		# Convert the image to base64 format
		base64_image = encoded_string.decode('utf-8')
		print(base64_image)

		# return render(request,'getinvoice.html',{'invoice':invoice,'customer_obj':customer_obj,'orders_obj':orders_obj,'trans_id':trans_id,'image':base64_image})
		data = {'invoice':invoice,'customer_obj':customer_obj,'orders_obj':orders_obj,'trans_id':trans_id,'image':base64_image}
		template = get_template('getinvoice.html')
		vat_value = CommissionSection.objects.all().first()
		html = template.render({'invoice':invoice,'customer_obj':customer_obj,'orders_obj':orders_obj,'trans_id':trans_id,'image':base64_image})
		response = HttpResponse(content_type='application/pdf')
		response['Content-Disposition'] = 'attachment; filename="file.pdf"'
		weasyprint.HTML(string=html).write_pdf(response,stylesheets=[weasyprint.CSS('static/store/css/invoice.css')])
		return response

class viewOrderDetails(View):
	@method_decorator(checkIfLoginStore,name="dispatch")
	def get(self,request,id):
		store_info = Stores.objects.filter(user_id=request.session['user_id']).first()
		invoice = orderPack.objects.filter(id=id).first()
		customer_obj = Buyer.objects.filter(id=invoice.customer_id).first()
		orders_obj = Cart.objects.filter(orderId = invoice.orderId,isPaid = True)
		trans_id = CustomerTransaction.objects.filter(orderPack_id = invoice.id ).first()
		return render(request,'view_order_details.html',{'invoice':invoice,'customer_obj':customer_obj,'orders_obj':orders_obj,'trans_id':trans_id,'store_info':store_info})

	

class couponListing(View):
	@method_decorator(checkIfLoginStore,name="dispatch")
	def get(self,request):
		store_info = Stores.objects.filter(user_id=request.session['user_id']).first()
		coupon = StoreCoupons.objects.filter(store_id=store_info).order_by('-id')
		paginator = Paginator(coupon, 10)
		page_number = request.GET.get('page')
		coupon_obj = paginator.get_page(page_number)
		return render(request,'coupon_listing.html',{'coupon_obj':coupon_obj,'store_info':store_info})

class addCouponStore(View):
	@method_decorator(checkIfLoginStore,name="dispatch")
	def get(self,request):
		store_info = Stores.objects.filter(user_id=request.session['user_id']).first()
		products = Products.objects.filter(end_date__isnull = True,store_id=store_info).order_by('-id')
		service =  storeServices.objects.filter(end_date__isnull = True,store_id=store_info)
		catgeory =  Products.objects.filter(end_date__isnull = True,store_id=store_info).values('maincategory__id','maincategory__category_name_english').distinct()
		print('category',catgeory)
		return render(request,'add_coupon_store.html',{'products':products,'service':service,'catgeory':catgeory,'store_info':store_info})
	
	def post(self,request):
		store_info = Stores.objects.filter(user_id=request.session['user_id']).first()
		form = forms.addCouponForm(request.POST)
		if form.is_valid():
			coupon_name_english = form.cleaned_data.get('coupon_name_english')
			coupon_name_arabic = form.cleaned_data.get('coupon_name_arabic')
			coupon_type = form.cleaned_data.get('coupon_type')
			coupon_discount =  form.cleaned_data.get('coupon_discount')
			product =  form.cleaned_data.get('product')
			if product:
				product_obj = Products.objects.filter(id=product,end_date__isnull = True,store_id=store_info).first()
			else:
				product_obj = None
			service = form.cleaned_data.get('service')
			if service:
				service_obj = Services.objects.filter(id=service).first()
			else:
				service_obj = None
			category_product = form.cleaned_data.get('category_product')
			if category_product:
				category_obj = MainCategories.objects.filter(id=category_product).first()
			else:
				category_obj = None
			coupon_on = form.cleaned_data.get('coupon_on')

			coupon_start_date =  form.cleaned_data.get('coupon_start_date')
			coupon_end_date =  form.cleaned_data.get('coupon_end_date')

			StoreCoupons.objects.create(store_id =store_info,coupon_name_english=coupon_name_english,coupon_name_arabic=coupon_name_arabic,
				  coupon_type=coupon_type, coupon_discount=coupon_discount,product=product_obj,service=service_obj, category_product=category_obj,
				 coupon_on=coupon_on, coupon_start_date=coupon_start_date,coupon_end_date=coupon_end_date)

			messages.success(request, "Coupon added successfully")
			return redirect('/coupon-listing')
		else:
			return render(request,'add_coupon_store.html')


class editCouponStore(View):
	@method_decorator(checkIfLoginStore,name="dispatch")
	def get(self,request,id):
		store_info = Stores.objects.filter(user_id=request.session['user_id']).first()
		products = Products.objects.filter(end_date__isnull = True,store_id=store_info).order_by('-id')
		service =  storeServices.objects.filter(end_date__isnull = True,store_id=store_info)
		catgeory =  Products.objects.filter(end_date__isnull = True,store_id=store_info).values('maincategory__id','maincategory__category_name_english').distinct()
		coupon_obj = StoreCoupons.objects.filter(id=id).first()
		print('category',catgeory)
		return render(request,'edit_coupon_store.html',{'products':products,'service':service,'catgeory':catgeory,'coupon_obj':coupon_obj,'store_info':store_info})
	def post(self,request,id):
		store_info = Stores.objects.filter(user_id=request.session['user_id']).first()
		form = forms.addCouponForm(request.POST)
		if form.is_valid():
			coupon_name_english = form.cleaned_data.get('coupon_name_english')
			coupon_name_arabic = form.cleaned_data.get('coupon_name_arabic')
			coupon_type = form.cleaned_data.get('coupon_type')
			coupon_discount =  form.cleaned_data.get('coupon_discount')
			product =  form.cleaned_data.get('product')
			if product:
				product_obj = Products.objects.filter(id=product,end_date__isnull = True,store_id=store_info).first()
			else:
				product_obj = None
			service = form.cleaned_data.get('service')
			if service:
				service_obj = Services.objects.filter(id=service).first()
			else:
				service_obj = None
			category_product = form.cleaned_data.get('category_product')
			if category_product:
				category_obj = MainCategories.objects.filter(id=category_product).first()
			else:
				category_obj = None
			coupon_on = form.cleaned_data.get('coupon_on')
			print('coupon_on',coupon_on)
			coupon_start_date =  form.cleaned_data.get('coupon_start_date')
			coupon_end_date =  form.cleaned_data.get('coupon_end_date')

			StoreCoupons.objects.filter(id=id).update(store_id =store_info,coupon_name_english=coupon_name_english,coupon_name_arabic=coupon_name_arabic,
				  coupon_type=coupon_type, coupon_discount=coupon_discount,product=product_obj,service=service_obj, category_product=category_obj,
				 coupon_on=coupon_on, coupon_start_date=coupon_start_date,coupon_end_date=coupon_end_date)

			messages.success(request, "Coupon Updated successfully")
			return redirect('/coupon-listing')
		else:
			return render(request,'edit_coupon_store.html')





class createServiceInvoice(View):
	@method_decorator(checkIfLoginStore,name="dispatch")
	def get(self,request,id):
		store_info = Stores.objects.filter(user_id=request.session['user_id']).first()
		data_obj = ServiceRequests.objects.filter(id=id,store=store_info.id).first()
		return render(request,'service-invoice.html',{'data_obj':data_obj,'store_info':store_info})

	def post(self,request,id):
		store_info = Stores.objects.filter(user_id=request.session['user_id']).first()
		admin_vat = CommissionSection.objects.all().first()
		form = forms.ServiceInvoiceForm(request.POST)
		if form.is_valid():
			unit_price = form.cleaned_data.get('unit_price')
			total_price = form.cleaned_data.get('total_price')
			quantity = form.cleaned_data.get('quantity')
			service_id = ServiceRequests.objects.filter(id=id,store=store_info.id).first()
			vat_amount = int(total_price)/100 * int(admin_vat.vat_percentage)
			check_existing = ServiceInvoice.objects.filter(store_id=store_info.id,service_request_id=service_id)
			if not check_existing:
				check_existing =  ServiceInvoice.objects.create(store_id=store_info.id,service_request_id=service_id)
				check_existing.invoice_number = set_invoice_number(check_existing.id)
				check_existing.unit_price = unit_price
				check_existing.total_before_vat = total_price
				check_existing.total_amount = float(total_price) + float(vat_amount)
				check_existing.english_service_name = service_id.serviceId.english_service_name
				check_existing.arabic_service_name = service_id.serviceId.arabic_service_name
				check_existing.quantity = quantity
				check_existing.description = service_id.notes
				check_existing.vat_amount = vat_amount
				check_existing.customer_name = service_id.customer.first_name + ' ' + service_id.customer.last_name
				check_existing.save()

				qr_unique_number = str(check_existing.customer_name)[:4]+ str(datetime.now()) + str(check_existing.total_amount)[:4] + str(check_existing.vat_amount)[:4]
				print("------------------",qr_unique_number)
				new_str = codecs.unicode_escape_decode(string_utils.shuffle(qr_unique_number))[0]
				encodedparceldetails = new_str.encode('utf-16', 'surrogatepass').decode('utf-16')
				url = pyqrcode.create(content=encodedparceldetails)
				import os
				if(os.path.exists(str(settings.BASE_DIR)+'/media/qrCode/')):
					pass
				else:
					os.mkdir(str(settings.BASE_DIR)+'/media/qrCode/')
				url.png(str(settings.BASE_DIR)+"/media/qrCode/"+check_existing.invoice_number+".png", scale = 8)
				image = os.path.join(str(settings.MEDIA_ROOT)+"qrCode/",check_existing.invoice_number+".png")
				print('image',image)
				check_existing.qr_code=image
				check_existing.save()



				# Open the image using Pillow
				path_to_image = "media/" + check_existing.qr_code.name

				# Construct the absolute path to the image file
				abs_path_to_image = os.path.join(os.getcwd(), path_to_image)

				# Open the image file using Pillow
				with open(abs_path_to_image, "rb") as image_file:
					encoded_string = base64.b64encode(image_file.read())

				# Convert the image to base64 format
				base64_image = encoded_string.decode('utf-8')
				print(base64_image)
				# import base64
				# print('----------------------','http://54.225.243.254:9006/media/'+image)
				# # Open the image file
				# file_path = "http://54.225.243.254:9006/media/"+image
				# with open(file_path, 'rb') as image_file:
				# 	# Read the image data
				# 	image_data = image_file.read()

				# 	# Encode the image data as a base64 string
				# 	base64_data = base64.b64encode(image_data).decode('utf-8')

				# 	# Print the base64 string
				# 	print(base64_data)



				context = {
					'check_existing': check_existing,
					'image':base64_image,
					'admin_vat':admin_vat,
					'store_info':store_info,
				}
				
				template = get_template('service-invoice-pdf.html')
				html = template.render(context)
				pdf_output = io.BytesIO()
				weasyprint.HTML(string=html).write_pdf(pdf_output, stylesheets=[weasyprint.CSS('static/store/css/invoice.css')])
				

				storage = FileSystemStorage(location=settings.MEDIA_ROOT)
				pdf_file_name = (str(settings.BASE_DIR)+"/media/InvoicePdf/"+f'invoice_{check_existing.invoice_number}.pdf')
				pdf_file_path = storage.save(pdf_file_name, pdf_output)


				
				check_existing.invoice_pdf_url  = pdf_file_path 
				check_existing.save()

				ServiceRequests.objects.filter(id=id,store=store_info.id).update(invoice_generated=True)
				messages.success(request,'Service invoice created successfully')
			else:
				messages.success(request,'Service Invoice already created')
			return redirect('/service-request-list')
		else:
			return render(request,'service-invoice.html',{'form':form})


class pdfInvoice(View):
	
	def get(self,request):
		return render(request,'service-invoice-pdf.html',)
