import datetime
import json
import os
import random
import math
import requests
import calendar
from users.models import UserCredentialsForBlockchain
from Blockchain2.decryption import decryptionOfPrivate, decryptionOfUrl, download_file_System,viewDecryptionOfUrl,hash_decrypation
from centralisedFileSystem.models import File, Script, ScreenPlay
from Blockchain2.DataStorage import uploadDataToIPFSNode
from Blockchain2.PPTConversion import UploadPPTConversionData, getPPTConversion, getUserprojectIds, deletePPTConversion
from Blockchain2.Conversion import UploadConversionData, getConversion, deleteConversion,scriptGetUserprojectIds
from lpp.certificate.createCertificate import certificateGenrate

from Blockchain2.blockchainsetting import OWNER_KEY

# from mnfapp.views import base, languages as lang ## import base,lang error commented 02032023
from .translation.translation_variables import code_2_language as languages, language_2_code
import re
# from .booktranslator.newConvertBook import convert_books
import shutil
import subprocess
import sys
import threading
import time
from datetime import date
from pathlib import Path
from subprocess import Popen
from threading import Thread
from auto_email.views import sendmail
import docx
import fitz
import pandas as pd
import razorpay
import stripe
from django.conf import settings
from django.contrib import messages
from django.contrib.auth.decorators import login_required
from django.contrib.auth.models import User
from django.core.files.base import ContentFile
from django.core.files.storage import FileSystemStorage
from django.core.mail import EmailMessage, EmailMultiAlternatives
from django.http import HttpResponse, HttpResponseRedirect, JsonResponse
from django.shortcuts import redirect, render
from django.template.loader import render_to_string
from django.utils.html import strip_tags
from forex_python.converter import CurrencyRates
from googletrans import Translator
from langdetect import detect
from pptx import Presentation
from pymongo import MongoClient
from PyPDF2 import PdfFileReader, PdfFileWriter
from pytz import timezone
from django.utils import timezone as tz
from tqdm import tqdm
from blockchain.submitIPFS import upload_multiFile_to_ipfs, upload_to_ipfs
from conversion.ppt_translation.final_srt_ppt import translate_presentation
from conversion.translation.translation_function import all_translator
from conversion.translation.translation_variables import (
    get_doc_file, get_language_script_code, get_pdf_save_dir,
    is_in_translation_list)
# from conversion.translation import final_translation
from conversion.translation.fourstepconversion import translate_function
from lpp.models import LPPTASKDatabase
# from .storytranslator.trans import convert_story
from lpp.views import task_assigner
from MNF.email import mnfnsendemail
from MNF.settings import (CONVERSION_PER_PAGE, COUNTRY_KEY, EMAIL_HOST_USER,
                          EMPLOY_DISCOUNT, LIFE_MEMBER_ADDITIONAL,
                          LPP_PER_PAGE, RAZORPAY_KEY_ID, RAZORPAY_KEY_SECRET,
                          RAZORPAY_PLATFORM_FEE, RUNNING_DISCOUNT_CONVERSION,
                          STRIPE_PLATFORM_FEE, STRIPE_PUBLISHABLE_KEY,
                          STRIPE_SECRET_KEY, T_RAZORPAY_KEY_ID,
                          T_RAZORPAY_KEY_SECRET, YEARLY_MEMBER_ADDITIONAL,
                          BasePath, pricing_data, discount_limit_handler, GetMongoDBUrl)
from mnfapp.models import *
from mnfapp.models import (MNFScriptDatabase, Notifications, PaymentData,
                           SampleScript, ScriptTranslations)
# from neutralAudit.tasks import NeutralAuditTask
# from ideamall.views import sendemail
from page_script.models import (Conversion_link, Conversions,
                                MNFScriptDatabase_2)
# from mnfapp.views import PaymentDetails
# from scriptAudit.script_audit_codes.script_audit import do_script_audit
# from neutralAudit.mnf_script_audit_v8 import call_script_audit_for_conversion
# from neutralAudit.views import audit1
from payment.models import conversionPayment, privilegedUser1
from users.models import *
from users.views import deduction_for_sep_wall
from utils import filesystem
# from page_script.views import service_update_internal
from utils.scripts_functions import (name_exists, script_id_generator,
                                     script_upload)
from utils.utilities import csv_to_docx, get_csv_from_id
from rest_framework.response import Response
from .booktranslator2.convertBookDocx import ConvertBook
from .forms import AScript, CScript, SScript
from .models import (BookConversion, StoryConversion, UploadScript,
                     pptconversion)
from .translation.detection import getInputs, language_detector, script_det
from .translation.final_transliteration_only import makeTransliteration_only
from .translation.script_reading import (breaksen, getRefined, getScenes,
                                         getSlugAndNonSlug, getSpeakers)
from .translation.script_writing import (addActionLine, addDialogue,
                                         addParenthetical, addSlugLine,
                                         addSpeaker, addTransition,
                                         dial_checker, dual_script,
                                         non_dial_checker)
from .translation.translation_function import (translate_comparison,
                                               ui_option3_and_4)
from .translation.translation_resources import google
from centralizePayment.views import callback, create_indent, centralPayment_get_discounts
from centralizePayment.models import CentralPayment
from mnfapp.models import centralDatabase
from institutional.views import get_discount
DISCOUNT = settings.DISCOUNT
from .translation.translation_variables import language_script
from mnfapp.views import update_juggernaut
from centralizePayment.views import auto_refund
# ppt convert


BASE_DIR = Path(__file__).resolve().parent.parent
basePath = BasePath()


# This is your real test secret API key.
# stripe.api_key = "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"
# stripe.api_key = "sk_test_51JT8ahSF9vzGWnggJT1M69LDT0Q8tCqvHzuWd9Fih5YO2guIpMpUd58swbDrJYocpQZAn3nY8k3Ymyw8QZ8dLeEF00VxfBmMWI"
stripe.api_key = STRIPE_SECRET_KEY
# STRIPE_PUB_KEY ="pk_test_51JT8ahSF9vzGWngg9ik0jueTIilHhCQomixBFOiNzCuo4Wwc5oRm73d05vdcboMgNwhyNcNTa2si8idqbB5msvwe006q3S96tM"
# STRIPE_PUB_KEY ="pk_live_51JT8ahSF9vzGWngg4N8fwhTPk5jq8fqBFdokqSMe7AVaOvH6BdyTwAfAoY79qkeJTFA0OdT5qkAk2FCNWCu6W9l000STNnHa7H"
STRIPE_PUB_KEY = STRIPE_PUBLISHABLE_KEY
# keyID = RAZORPAY_KEY_ID
# keySecret = RAZORPAY_KEY_SECRET


def adding_sample_scripts(request):
    return redirect("sampleScriptC")


class sendemail(threading.Thread):
    def __init__(self, whomtosend, titleofmail, dateofemail, context, EMAIL_HOST_USER):
        self.whomtosend = whomtosend
        self.titleofmail = titleofmail
        self.dateofemail = dateofemail
        self.context = context
        self.EMAIL_HOST_USER = EMAIL_HOST_USER
        threading.Thread.__init__(self)

    def run(self):
        print("run self class", self.context)
        subject = str(self.titleofmail) + " " + str(self.dateofemail) + "."
        from_email = self.EMAIL_HOST_USER
        to = self.whomtosend

        html_content = render_to_string(
            rf"{basePath}/ideamall/templates/ideamall/email_templete.html",
            self.context,  # /home/user/mnf/project/MNF/ideamall/templates/ideamall/email_templete.html
        )  # render with dynamic value
        # Strip the html tag. So people can see the pure text at least.
        text_content = strip_tags(html_content)
        # create the email, and attach the HTML version as well.
        msg = EmailMultiAlternatives(subject, text_content, from_email, [to])
        msg.attach_alternative(html_content, "text/html")
        msg.send()


def set_payment_token(request):
    if request.user.is_superuser:
        request.session["keyID"] = T_RAZORPAY_KEY_ID
        request.session["keySecret"] = T_RAZORPAY_KEY_SECRET
    else:
        request.session["keyID"] = RAZORPAY_KEY_ID
        request.session["keySecret"] = RAZORPAY_KEY_SECRET


# languages = {
#     "hi": "Hindi",
#     "en": "English",
#     "ur": "Urdu",
#     "ar": "Arabic",
#     "bn": "Bengali",
#     "kn": "Kannada",
#     "ta": "Tamil",
#     "bg": "Bulgarian",
#     "bn": "Bengali",
#     "ml": "Malayalam",
#     "ru": "Russian",
#     "sr": "Serbian",
#     "uk": "Ukranian",
#     "hr": "Croatian",
#     "ga": "Irish",
#     "sq": "Albanian",
#     "mr": "Marathi",
#     "fa": "Persian",
#     "te": "Telugu",
#     "tr": "Turkish",
#     "hu": "Hungarian",
#     "it": "Italian",
#     "ro": "Romanian",
#     "pa": "Punjabi",
#     "gu": "Gujarati",
#     "or": "Oriya",
#     "zh-CN": "Chinese-Simplified",
#     "zh-TW": "Chinese-Traditional",
#     "ne": "Nepali",
#     "fr": "French",
#     "es": "Spanish",
#     "id": "Indonesian",
#     "el": "Greek",
#     "ja": "Japanese",
#     "jv": "Javanese",
#     "ko": "Korean",
#     "be": "Belarusian",
#     "uz": "Uzbek",
#     "sd": "Sindhi",
#     "af": "Afrikaans",
#     "de": "German",
#     "is": "Icelandic",
#     "ig": "Igbo",
#     "la": "Latin",
#     "pt": "Portugese",
#     "my": "Myanmar",
#     "th": "Thai",
#     "su": "Sundanese",
#     "lo": "Lao",
#     "am": "Amharic",
#     "si": "Sinhala",
#     "az": "Azerbaijani",
#     "kk": "Kazakh",
#     "mk": "Macedonian",
#     "bs": "Bosnian",
#     "ps": "Pashto",
#     "mg": "Malagasy",
#     "ms": "Malay",
#     "yo": "Yoruba",
#     "cs": "Czech",
#     "da": "Danish",
#     "nl": "Dutch",
#     "tl": "Tagalog",
#     "no": "Norwegian",
#     "sl": "Slovenian",
#     "sv": "Swedish",
#     "vi": "Vietnamese",
#     "cy": "Welsh",
#     "he": "Hebrew",
#     "hy": "Armenian",
#     "km": "Khmer",
#     "ka": "Georgian",
#     "mn": "Mongolian",
#     "ku": "Kurdish",
#     "ky": "Kyrgyz",
#     "tk": "Turkmen",
#     "fi": "Finnish",
#     "ht": "Haitian Creole",
#     "haw": "Hawaiian",
#     "lt": "Lithuanian",
#     "lb": "Luxembourgish",
#     "mt": "Maltese",
#     "pl": "Polish",
#     "eo": "Esperanto",
#     "tt": "Tatar",
#     "ug": "Uyghur",
#     "ha": "Hausa",
#     "so": "Somali",
#     "sw": "Swahili",
#     "yi": "Yiddish",
#     "eu": "Basque",
#     "ca": "Catalan",
#     "ceb": "Cebuano",
#     "co": "Corsican",
#     "et": "Estonian",
#     "fy": "Frisian",
#     "gl": "Galician",
#     "hmn": "Hmong",
#     "rw": "Kinyarwanda",
#     "lv": "Latvian",
#     "mi": "Maori",
#     "sm": "Samoan",
#     "gd": "Scots Gaelic",
#     "st": "Sesotho",
#     "sn": "Shona",
#     "sk": "Slovak",
#     "xh": "Xhosa",
#     "zu": "Zulu",
#     "ny": "Nyanja",
# }

def conversionSHandler(script_id="scr_1652429491"):
    script_info = MNFScriptDatabase.objects.get(script_id=script_id)
    numPages = script_info.numPages
    total_amount = 0
    context = {}
    if int(numPages) > 5:
        context["subtotal"] = round(float(numPages * settings.CONVERSION_PER_PAGE), 2)
    return context


def conversion_script_details(script_id="scr_1652429491"):
    script_info = MNFScriptDatabase.objects.get(script_id=script_id)
    context = {}
    context["script_title"] = script_info.script_title
    context["numPages"] = script_info.numPages
    context["ndial_src"] = script_info.nondial_src_language
    context["dial_src"] = script_info.dial_src_language
    context["ndial_dest"] = script_info.nondial_dest_language
    context["dial_dest"] = script_info.dial_dest_language
    context["dial_dest_script"] = script_info.dial_dest_script
    return context


def conversionScriptInvoice(request, script_id="scr_1652429491"):
    context = {}
    script_details = conversion_script_details(script_id)
    context.update(script_details)
    tempt = conversionSHandler(script_id=script_id)
    context.update({"subtotal":tempt["subtotal"]})
    
    return render(request, "conversion/conversion_checkout.html", context)


# -> For Testing of Conversion
def run_testing(request):
    # from conversion.translation.testing_scripts import test_run
    # from conversion.translation.testing_scripts_mini import test_run
    from threading import Thread

    # from conversion.translation.testing_languages import test_run
    # from conversion.translation.testing_languages_working_translation import test_run
    # from conversion.translation.getting_languages_Scripts import test_run
    # from conversion.translation.getting_languages_Codes import test_run
    from conversion.translation.testing_response_times import test_run
    # create a thread
    thread = Thread(target=test_run)
    # run the thread
    thread.start()
    # wait for the thread to finish
    print("Waiting for the thread...")
    thread.join()
    test_run()
    return render(request, "conversion/testing.html")


def multi_lang(request):
    f = open("/home/user/mnf/project/MNF/locale/hi/LC_MESSAGES/django.po", "r")
    g = open("/home/user/mnf/project/MNF/locale/hi/LC_MESSAGES/django_.po", "w")
    appender = ""

    for line in f:
        if line[0:5] == "msgid":
            if line[7:-2] != "":
                output = all_translator(
                    line[7:-2], "en", "hi").replace(""", "\"")
                g.write(line)
                appender = output
            else:
                g.write(line)
        elif line[0:6] == "msgstr":
            g.write(rf'msgstr "{appender}"')
            g.write("\n")
            appender = ""
        else:
            g.write(line)
    g.close()

    return render(request, "conversion/testing.html")


# -> Converting Docx to PDF
def convert_to_pdf(input_docx, out_folder):
    p = subprocess.Popen(
        [
            "libreoffice",
            "--headless",
            "--convert-to",
            "pdf",
            "--outdir",
            out_folder,
            input_docx,
        ]
    )
    print(["--convert-to", "pdf", input_docx])
    p.communicate()


# -> Counting Number of Pages
def countPages(docfile, pdfname):
    convert_to_pdf(docfile, rf"{basePath}/media/PdfFiles/")
    pdf = PdfFileReader(open(rf"{basePath}/media/PdfFiles/{pdfname}", "rb"))
    number_of_pages = pdf.getNumPages()
    return number_of_pages


# -> Conversion Script Storing and redirecting to Script Page
def ps_conversion(request):
    if request.method == "POST":
        try:
            script_id = script_upload(request.FILES["script"], request.user)[
                "script_id"
            ]
        except FileExistsError:
            messages.error(
                request, 'Script Already Exists ! Please choose a New Script')
            #messages.success(request, f"Script Already Exists ! Please choose a New Script")
            return redirect("conversion")

        # NeutralAuditTask().delay(script_id=script_id, user=request.user)
        # NeutralAudit(script_id=script_id).audit()

        return redirect("ScriptPage", script_id=script_id)


def conversion_clone(request):
    print("Entered Conversion Function")
    sampleList = SampleScript.objects.all()
    with open(f"{basePath}/MNF/json_keys/language_pairs.json") as c:
        language_pairs = json.load(c)
    with open(f"{basePath}/MNF/json_keys/default_script.json") as c:
        default_script = json.load(c)
    with open(f"{basePath}/MNF/json_keys/script_pairs.json") as c:
        script_pairs = json.load(c)
    if request.method == "POST":
        print("i am here 0")
        # try:
        print("i am here 1")
        M = MNFScriptDatabase()
        UScript = CScript(request.POST, request.FILES)
        if UScript.is_valid():
            M.script = UScript.cleaned_data.get("script")
            M.user_id = request.user
            M.progress = 10
            M.save()
            author_name = str(request.user.username)
            script_title = M.script.name
            numPages = countPages(
                str(BASE_DIR) + "/media/" +
                script_title, script_title[8:-4] + "pdf"
            )
            request.session["numPages"] = numPages
            MyURL = "/media/" + str(script_title)
            formInput = getInputs(request, str(BASE_DIR) + MyURL)
            dial_src_script = formInput[2]
            dial_src_lang = formInput[1]
            non_dial_src_lang = formInput[0]
            non_dial_src_script = formInput[3]
            option3 = formInput[4]
            option4 = formInput[5]
            option5 = formInput[6]
            option6 = formInput[7]
            M.progress = 20
            M.save()
            M.progress = 90
            M.save()
            print("i am here 2")
            print("The Data of formInput is:", formInput)
            context = {
                "id": M.id,
                "numPages": numPages,
                "fileName": MyURL,
                "non_dial_src_script": non_dial_src_script,
                "author_name": author_name,
                "script_title": script_title,
                "UScript": UScript,
                "dial_src_script": dial_src_script,
                "dial_src_lang": dial_src_lang,
                "dial_src_lang_full": languages.get(dial_src_lang),
                "non_dial_src_lang_full": languages.get(non_dial_src_lang),
                "non_dial_src_lang": non_dial_src_lang,
                "list": sampleList,
                "option3": option3,
                "option4": option4,
                "option5": option5,
                "option6": option6,
                "language_pairs": language_pairs,
                "default_script": default_script,
                "script_pairs": script_pairs,
            }
            print("i am here 3")
            return render(request, "conversion/conversion_copy.html", context)
        # except Exception as e:
        #     print("i am here 4")
        #     print("Error:", e)
        #     messages.warning(request, "The format of file is wrong")
        #     return redirect("conversion_clone")
    # print("i am here 5")
    return render(
        request,
        "conversion/conversion_clone.html",
        {
            "list": sampleList,
            "language_pairs": language_pairs,
            "default_script": default_script,
            "script_pairs": script_pairs,
        },
    )


# -> Initital Saving of Script in database and extracting various languages present in that
def conversion(request):
    from utils.utilities import fdx_to_txt
    print("Entered Conversion Function")
    existingscripts = MNFScriptDatabase.objects.filter(user_id=request.user.id).order_by("-date_at").values_list('script_id', 'script_file_path')
    sampleList = SampleScript.objects.all()
    with open(f"{basePath}/MNF/json_keys/language_pairs.json") as c:
        language_pairs = json.load(c)
    with open(f"{basePath}/MNF/json_keys/script_pairs.json") as c:
        script_pairs = json.load(c)
    if request.method == "POST":
        # try:
        M = MNFScriptDatabase()
        UScript = CScript(request.POST, request.FILES)
        if UScript.is_valid():
            M.script = UScript.cleaned_data.get("script")
            M.user_id = request.user
            M.progress = 10
            M.save()
            author_name = str(request.user.username)
            script_title = M.script.name
            # if ((((M.script.name).split("/"))[-1]).split("."))[-1] == "fdx":
            #     try:
            #         f = open(str(BASE_DIR) + "/media/" + script_title, "r")
            #         print("Step 1 done")
            #         text = fdx_to_txt(f)
            #         doc = docx.Document()
            #         doc.add_paragraph(text)
            #         print("Step 1.2 done")
            #         doc.save(str(BASE_DIR) + "/media/" + str((script_title.split("."))[0]) + "-1.docx")
            #         print("Step 4 done")
            #         numPages = countPages(
            #             str(BASE_DIR) + "/media/" + str((script_title.split("."))[0]) + "-1.docx",
            #             str(script_title[8:-4]) + "-1.pdf"
            #         )
            #         print("Step 5 done")
            #     except Exception as e:
            #         print(f"Error :", e)
            #         numPages = 1
            # elif ((((M.script.name).split("/"))[-1]).split("."))[-1] == "pdf":
            #     pdf = PdfFileReader(open(str(BASE_DIR) + "/media/" + script_title))
            #     numPages = pdf.getNumPages()
            # else:
            #     numPages = countPages(
            #         str(BASE_DIR) + "/media/" +
            #         script_title, script_title[8:-4] + "pdf"
            #     )

            MyURL = "/media/" + str(script_title)
            formInput = getInputs(request, str(BASE_DIR) + MyURL, M.id)
            dial_src_script = formInput[2]
            dial_src_lang = formInput[1]
            non_dial_src_lang = formInput[0]
            non_dial_src_script = formInput[3]
            option3 = formInput[4]
            option4 = formInput[5]
            option5 = formInput[6]
            option6 = formInput[7]
            numPages = formInput[8]
            request.session["numPages"] = numPages
            M.progress = 20
            M.save()
            print("numpages", numPages)
            # if UserCredentialsForBlockchain.objects.filter(user=request.user).exists():
            #     blockchain_obj = UserCredentialsForBlockchain.objects.get(user=request.user)
            #     certificatepath = certificateGenrate(request.user.username,"original script",hash)
            #     hash = uploadDataToIPFSNode(UScript.cleaned_data.get("script"))
            #     userkey = decryptionOfPrivate(blockchain_obj.privateKey)
            #     to_email = [request.user.email]
            #     email_code = 'BL1'
            #     key_value = {
            #         "service":"original script",
            #         "hash": hash,
            #         "public key":blockchain_obj.publicKey,
            #         "private key":userkey.decode('utf-8'),
            #     }
            #     sendmail(to_email=to_email , email_code=email_code,key_value=key_value,filePath=certificatepath)


            M.progress = 90
            M.save()
            print("The Data of formInput is:", formInput)

            context = {
                "id": M.id,
                "numPages": numPages,
                "fileName": MyURL,
                "non_dial_src_script": non_dial_src_script,
                "author_name": author_name,
                "script_title": (((str(script_title).split("/"))[-1]).split("."))[0],
                "UScript": UScript,
                "dial_src_script": dial_src_script,
                "dial_src_lang": dial_src_lang,
                "dial_src_lang_full": languages.get(dial_src_lang),
                "non_dial_src_lang_full": languages.get(non_dial_src_lang),
                "non_dial_src_lang": non_dial_src_lang,
                "list": sampleList,
                "option3": option3,
                "option4": option4,
                "option5": option5,
                "option6": option6,
                "language_pairs": language_pairs,
                "default_script": language_script,
                "script_pairs": script_pairs,
                "exsiting_scripts": existingscripts,
            }
            print("i am here 3")
            return render(request, "conversion/conversion.html", context)

        # except Exception as e:
        #     print("Error:",e)
        #     print("i am here 4")
        #     messages.warning(request, "The format of file is wrong")
        #     return redirect("conversion")

    return render(
        request,
        "conversion/conversion.html",
        {
            "list": sampleList,
            "language_pairs": language_pairs,
            "default_script": language_script,
            "script_pairs": script_pairs,
            "exsiting_scripts": existingscripts,
        },
    )


def is_processing_complete(request):
    # script_id = request.GET["script_id"]
    obj = MNFScriptDatabase.objects.filter(user_id=request.user.id).last()
    print("Processing Chal Rahi hai", obj.progress)
    if obj.progress == 100:
        return JsonResponse({"status": "success"}, status=200)
    else:
        return JsonResponse({"status": "pending", "progress": obj.progress}, status=202)


# -> At 10sec intervals check if conversion completed
def is_converted(request):
    script_id = request.GET["script_id"]
    if request.GET["centralised"] == "yes":
        z = Conversion_link.objects.get(
            script_name=MNFScriptDatabase_2.objects.get(script_id=script_id)
        )
        objs = z.conversions.all()
        for indx, obji in enumerate(objs):
            if indx == len(objs) - 1:
                obj = obji
            else:
                pass
    else:
        obj = MNFScriptDatabase.objects.get(script_id=script_id)
    print("obj.script convetred function", obj.translated_script_path)
    if obj.translated_script_path:
        return JsonResponse({"status": "success"}, status=200)
    else:
        return JsonResponse({"status": "pending"}, status=202)


# -> Actually Running Translation and Transliteration of script
def make_conversion(request):
    # for key,value in request.GET.items()
    original_stdout = sys.stdout
    print("MAke Conversion mein hu")
    script_file_path = request.GET["script_file_path"]
    request_id = request.GET["request_id"]
    str1 = str(script_file_path)
    if str1[41:45] == "user":
        script_file_path = "/home/" + str(str1[41:])
    script_id = request.GET["script_id"]
    dial_conv_script = request.GET["dial_conv_script"]
    dial_src_lang = request.GET["dial_src_lang"]
    non_dial_src_lang = request.GET["non_dial_src_lang"]
    dial_src_script = request.GET["dial_src_script"]
    restrict_to_five = request.GET["restrict_to_five"]
    option3 = request.GET.get("option3")
    option4 = request.GET.get("option4")
    option5 = request.GET.get("option5")
    option6 = request.GET.get("option6")
    # -> Saving options
    script_data = MNFScriptDatabase.objects.get(script_id = script_id)
    script_data.option3 = option3
    script_data.option4 = option4
    script_data.option5 = option5
    script_data.option6 = option6
    script_data.save()

    if request.GET["centralised"] == "yes":
        service_update_internal(script_id, request_id,
                                "Conversion", "20% Completed")
        z = Conversion_link.objects.get(
            script_name=MNFScriptDatabase_2.objects.get(script_id=script_id)
        )
        objs = z.conversions.all()
        for indx, obji in enumerate(objs):
            if indx == len(objs) - 1:
                obj = obji
            else:
                pass
        script_file_path = str(basePath) + script_file_path
        script = str(
            MNFScriptDatabase_2.objects.get(script_id=script_id).script_name
        )
        dial_dest_lang = obj.dial_dest_language
        dial_dest_script = obj.dial_dest_script
        non_dial_dest_lang = obj.nondial_dest_language
        dual_dial_script = obj.dual_dial_script  # Yes,No

    else:
        # user_script_data = MNFScriptDatabase.objects.get(script_id=script_id)
        scripttt = script_file_path
        # dial_dest_lang = user_script_data.dial_dest_language
        # dial_dest_script = user_script_data.dial_dest_script
        # non_dial_dest_lang = user_script_data.nondial_dest_language
        # dual_dial_script = user_script_data.dual_dial_script  # Yes,No

    # -> Audit Code
    sys.stdout = original_stdout
    start_time = time.time()
    # print("----Auditing----")

    # -> Audit Code starts here
    name_script = str(((((scripttt).split("/"))[-1]).split("."))[0])
    print("name if script", name_script)
    """if file is not a sample script and not a existing script then only audit it"""
    print("sample script", request.GET.get("sample_id"))
    print("existing_script", request.session.get("existing_script"))
    if not request.session.get('existing_script') and not request.GET["sample_id"]:
        print("----Auditing----")
        script1 = str(scripttt)
        doc = open(script1, 'rb').read()
        file = ContentFile(
            doc,
            (script1.split("/"))[-1],
        )
        language_code = "en"
        result = filesystem.new_screenplay(
            request.user,
            request.user.username,
            str(name_script),
            file,
            "script-original",
            language_code,
        )
        # result = filesystem.new_screenplay_without_audit_in_background
        audit_id = result.get("script", {}).get("id")
        # audit_found = False
        from scriptAudit.mnf_script_audit import NeutralAudit
        # while audit_found != True:
        try:
            NeutralAudit(audit_id)
            to_email = [request.user.email]
            email_code = 'SB1'
            print("Hulalala 1212")
            sendmail(to_email=to_email, email_code=email_code)
            # audit_found = True

        except:
            to_email = [request.user.email]
            email_code = 'SB2'
            print("Hulalala 1213")
            sendmail(to_email=to_email, email_code=email_code)

        # file_path_ = filesystem.get_file_path(audit_id, "script-csv")
        file_path_ = filesystem.get_file_path(audit_id, "script-csv")
        # to_email = [request.user.email]
        # email_code = 'SB1'
        # sendmail(to_email=to_email, email_code=email_code)
        script_data = MNFScriptDatabase.objects.get(script_id=script_id)
        script_data.audit_id = str(audit_id)
        script_data.save()
        try:
            df = pd.read_csv(file_path_, encoding="utf-8")
        except UnicodeError:
            df = pd.read_csv(file_path_, encoding="utf-16")
        pd.set_option('display.max_rows', None)
        pd.set_option('display.max_columns', None)
        # sys.stdout = original_stdout
        dataframe = df
        list_of_lists = dataframe.values.tolist()
        sys.stdout = original_stdout
        print(rf"dataframe,{dataframe}")
        # audited_file = csv_to_docx(dataframe)
        # audited_file.save(basePath + "/media/" + str(scripttt))
        # audited_file.save(str(scripttt))
        print("Audit Done")


    elif request.GET["sample_id"]:
        from mnfapp.models import SampleScript
        sample_script = SampleScript.objects.get(sample_id=request.GET["sample_id"])
        if sample_script.audit_id:
            print("already audited")
            audit_id = sample_script.audit_id
            audit_found = False
            while audit_found != True:
                try:
                    file_path_ = filesystem.get_file_path(
                        sample_script.audit_id, "script-csv")
                    audit_found = True
                except:
                    pass
            # file_path_ = filesystem.get_file_path(
            #     sample_script.audit_id, "script-csv")
            try:
                df = pd.read_csv(file_path_, encoding="utf-8")
            except UnicodeError:
                df = pd.read_csv(file_path_, encoding="utf-16")
            pd.set_option('display.max_rows', None)
            pd.set_option('display.max_columns', None)
            # sys.stdout = original_stdout
            dataframe = df
            list_of_lists = dataframe.values.tolist()
            sys.stdout = original_stdout
        else:
            # scripttt = SampleScript
            print("----Auditing----")
            script1 = str(scripttt)
            doc = open(script1, 'rb').read()
            file = ContentFile(
                doc,
                (script1.split("/"))[-1],
            )
            language_code = "en"
            result = filesystem.new_screenplay(
                request.user,
                request.user.username,
                str(name_script),
                file,
                "script-original",
                language_code,
            )
            # result = filesystem.new_screenplay_without_audit_in_background
            audit_id = result.get("script", {}).get("id")
            audit_found = False
            while audit_found != True:
                try:
                    file_path_ = filesystem.get_file_path(
                        audit_id, "script-csv")
                    audit_found = True
                except:
                    pass
            sample_script.audit_id = str(audit_id)
            sample_script.save()
            try:
                df = pd.read_csv(file_path_, encoding="utf-8")
            except UnicodeError:
                df = pd.read_csv(file_path_, encoding="utf-16")
            pd.set_option('display.max_rows', None)
            pd.set_option('display.max_columns', None)
            # sys.stdout = original_stdout
            dataframe = df
            list_of_lists = dataframe.values.tolist()
            sys.stdout = original_stdout
            print(rf"dataframe,{dataframe}")
            # audited_file = csv_to_docx(dataframe)
            # audited_file.save(basePath + "/media/" + str(scripttt))
            # audited_file.save(str(scripttt))
            print("Audit Done")


    elif request.session.get('existing_script'):
        if MNFScriptDatabase.objects.get(script_id=script_id).audit_id:
            audit_id = MNFScriptDatabase.objects.get(script_id=script_id).audit_id
            print("already audited")
            # audit_id = sample_script.audit_id
            audit_found = False
            while audit_found != True:
                try:
                    file_path_ = filesystem.get_file_path(
                        audit_id, "script-csv")
                    audit_found = True
                except:
                    pass
            # file_path_ = filesystem.get_file_path(
            #     sample_script.audit_id, "script-csv")
            try:
                df = pd.read_csv(file_path_, encoding="utf-8")
            except UnicodeError:
                df = pd.read_csv(file_path_, encoding="utf-16")
            pd.set_option('display.max_rows', None)
            pd.set_option('display.max_columns', None)
            # sys.stdout = original_stdout
            dataframe = df
            list_of_lists = dataframe.values.tolist()
            # sys.stdout = original_stdout
        else:

            # scripttt = SampleScript
            print("----Auditing----")
            script1 = str(scripttt)
            doc = open(script1, 'rb').read()
            file = ContentFile(
                doc,
                (script1.split("/"))[-1],
            )
            language_code = "en"
            result = filesystem.new_screenplay(
                request.user,
                request.user.username,
                str(name_script),
                file,
                "script-original",
                language_code,
            )
            # result = filesystem.new_screenplay_without_audit_in_background
            audit_id = result.get("script", {}).get("id")
            audit_found = False
            while audit_found != True:
                try:
                    file_path_ = filesystem.get_file_path(
                        audit_id, "script-csv")
                    audit_found = True
                except:
                    pass

            script_data = MNFScriptDatabase.objects.get(script_id=script_id)
            script_data.audit_id=str(audit_id)
            script_data.save()
            # sample_script.audit_id = str(audit_id)
            # sample_script.save()
            try:
                df = pd.read_csv(file_path_, encoding="utf-8")
            except UnicodeError:
                df = pd.read_csv(file_path_, encoding="utf-16")
            pd.set_option('display.max_rows', None)
            pd.set_option('display.max_columns', None)
            # sys.stdout = original_stdout
            dataframe = df
            list_of_lists = dataframe.values.tolist()
            sys.stdout = original_stdout
            print(rf"dataframe,{dataframe}")
            # audited_file = csv_to_docx(dataframe)
            # audited_file.save(basePath + "/media/" + str(scripttt))
            # audited_file.save(str(scripttt))
            print("Audit Done")

    # -> Audit Code ends here
    sys.stdout = original_stdout
    print("Conversion Translation is Starting")
    print(
        rf'translate_function("{script_file_path}", "{script_id}", "{request.session.get("translation_id", None)}","{dial_conv_script}", "{dial_src_lang}","{non_dial_src_lang}", "{dial_src_script}", "{restrict_to_five}", "{option3}", "{option4}", "{option5}", "{option6}")'
    )
    sys.stdout = original_stdout
    if request.GET["centralised"] == "yes":

        service_update_internal(script_id, request_id,
                                "Conversion", "30% Completed")
        pass
    try:
        to = request.user.email
        key_value = {
            "User": request.user.username,
        }
        sendmail(to_email=[to], email_code="PP17", key_value=key_value)
        sys.stdout = original_stdout
        # f = open("/home/user/mnf/project/MNF/log/debug2255.log", "w")
        # sys.stdout = f
        translate_function(
            audit_id,
            list_of_lists,
            script_file_path,
            script_id,
            request.session.get('translation_id', None),
            dial_src_lang,
            non_dial_src_lang,
            dial_src_script,
            restrict_to_five,
            option3,
            option4,
            option5,
            option6,
            request.GET.get("centralised"),
            request.GET.get("sample_id"),
            request.GET.get("sample_title"),
        )
        # f.close()
        try:
            script_original = MNFScriptDatabase.objects.get(script_id=script_id)
            script_translated = ScriptTranslations.objects.get(translation_id=request.session.get('translation_id', None))
            update_juggernaut(request, user_id=request.user.id, service_name="conversion",
                              conversion_pages=request.session['juggernaut_pages_deduction'],
                              associated_project=script_original,
                              translation_language=str(script_translated.dial_dest_language))
            script_original.is_juggernaut_used = True
            if script_original.languages_juggernaut != "":
                script_original.languages_juggernaut = str(script_original.languages_juggernaut) + "," + str(script_translated.dial_dest_language)
            else:
                script_original.languages_juggernaut = str(script_translated.dial_dest_language)
            script_original.save()
        except Exception as e:
            print("Error is:", e)

    except Exception as e:
        print("Error:", e)
        print(
            "Script translation failed due to some internal error. If you have made any payment for conversion "
            "that will be refunded"
        )
        if request.POST.get("centralised") == "yes":
            obj = MNFScriptDatabase_2.objects.get(script_id=script_id)
        else:
            obj = MNFScriptDatabase.objects.get(script_id=script_id)
        print("obj.script converted function", obj.translated_script_path)

        # auto refund code
        auto_refund(ScriptTranslations.objects.get(translation_id=request.session.get('translation_id', None)).central_payment_id)
        # email for failure
        to = request.user.email
        key_value = {
            "User": request.user.username,
        }
        sendmail(to_email=[to], email_code="PP21", key_value=key_value)
        return JsonResponse({}, status=505)
    sys.stdout = original_stdout
    # blockchain here
    scriptconversion = {}
    try:
        # from pymongo import MongoClient
        # MongoDBUrl = GetMongoDBUrl()
        # client = MongoClient(MongoDBUrl)
        # db = client.DB
        # ScriptDatabase = "mnfapp_scripttranslations"
        # scriptconversion = []
        # scriptconversion = ScriptTranslations.objects.get(translation_id = request.session.get('translation_id', None))
        # scriptconversion.pop("_id")
        # scriptconversion.pop("date_translated")
        print("blockchain script conversion 1")
        current_datetime = datetime.datetime.now()
        if UserCredentialsForBlockchain.objects.filter(user=request.user).exists():
            print("blockchain script conversion 2")
            obj = ScriptTranslations.objects.get(translation_id=request.session.get('translation_id', None))
            obj2 = MNFScriptDatabase.objects.get(script_id=script_id)
            temp1 = (str(obj2.script_file_path).split("media/"))[1]
            temp2 = str(obj.translated_script_path)
            uploaded_script = f"{basePath}/media/{temp1}"
            translated_script = f"{basePath}{temp2}"
            # scriptconversion = script_info
            print("blockchain script conversion 3")
            with open(uploaded_script, 'rb') as f:
                hash = uploadDataToIPFSNode(f)
                scriptconversion["original_scriptFile_hash"] = hash
            scriptconversion["original_scriptFile_path"] = uploaded_script
            scriptconversion["date_at"] = current_datetime.strftime(
                "%Y-%m-%d %H:%M:%S")
            print("blockchain script conversion 4")
            with open(translated_script, 'rb') as f1:
                hash = uploadDataToIPFSNode(f1)
                scriptconversion["translated_scriptFile_hash"] = hash
            scriptconversion["translated_scriptFile_path"] = translated_script
            # docx_file_path = translated_script.replace(".pdf", ".docx") 
            # docxfile_name = docx_file_path.split("/")[-1]
            # docxfile_name ="translate_docx_file.docx"
            #
            # with open(docx_file_path, 'rb') as f2:
            #     hash1 = uploadDataToIPFSNode(f2)
            #     scriptconversion["translated_docxscriptFile_hash"] = hash1
            # scriptconversion["docxfile_name"] = docxfile_name
            print("blockchain script conversion 5")
            blockchain_obj = UserCredentialsForBlockchain.objects.get(
                user=request.user)
            UserId = blockchain_obj.user_id
            Project = request.session.get('translation_id', None)
            Data = str(scriptconversion)
            userPrivateKey = blockchain_obj.privateKey
            userkey = decryptionOfPrivate(userPrivateKey)
            # hash1 = UploadConversionData(OWNER_KEY,blockchain_obj.publicKey, UserId, str(Project), Data)
            # transaction_hash = UploadConversionData(tx_id)
            tx_id = UploadConversionData(OWNER_KEY, blockchain_obj.publicKey, UserId, str(Project), Data)
            print("blockchain script conversion 6")
            print("scriptconversion hash >>>>>>>>>>>>>>>", hash1)
            certificatepath = certificateGenrate(request.user.username,"script conversion",hash)
            hash = hash_decrypation(hash)
            to_email = [request.user.email]
            email_code = 'BL1'
            key_value = {
                "service":"script conversion",
                "hash": hash,
                "public key":blockchain_obj.publicKey,
                "private key":userkey.decode('utf-8'),
                "Transaction Hash": tx_id
            }
            sendmail(to_email=to_email , email_code=email_code,key_value=key_value,filePath=certificatepath)

    except Exception as e:
        print("Error in blockchain is", e)
        pass

    to = request.user.email
    key_value = {
        "User": request.user.username,
        "title": (((str(obj2.script_file_path).split("/"))[-1]).split("."))[0]
    }
    sendmail(to_email=[to], email_code="PP18", key_value=key_value)

    if request.GET["centralised"] == "yes":
        service_update_internal(script_id, request_id,
                                "Conversion", "90% Completed")
        pass

    if request.GET.get("to_be_vetted_by_lpp") == "on":
        if request.POST.get("centralised") == "yes":
            # Vetting is not allowed from Page_script conversions
            pass
        else:
            obj = ScriptTranslations.objects.get(translation_id=request.session.get('translation_id', None))
            X = LPPTASKDatabase()
            X.user_id = obj.user_id
            X.usernote = "Kindly check if the translated file is correct as per the Uploaded Document!"
            X.translated_script = obj
            X.generated_from = "conversion"
            temp_amount = request.session["amount_without_subscrption"]
            X.amoutgiventolpp_action = round((temp_amount / 2), 2)
            X.amoutgiventolpp_dialogue = round((temp_amount / 2), 2)
            X.save()
            task_assigner(int(X.task_id), "conversion")
    try:
        # obj = ScriptTranslations.objects.get(translation_id=request.session.get('translation_id', None))
        temp1 = str(obj2.script_file_path)
        temp2 = str(obj.translated_script_path)
        uploaded_script = f"{temp1}"
        translated_script = f"{basePath}{temp2}"

        data = [uploaded_script, translated_script]
        files, timestamp = upload_multiFile_to_ipfs(
            data, obj2.script_title, "convertScript", obj.user_id.email)
        obj.timestamp = timestamp
        obj.uploaded_script_encoded = files[0]
        obj.translated_script_encoded = files[1]
        obj.save()
    except:
        pass
    print("Script Translated successfully and Sent for Vetting if chosen")
    if request.GET["centralised"] == "yes":
        pass
        service_update_internal(script_id, request_id,
                                "Conversion", "Completed")
    # user = request.user
    # subject = "Conversion Generated Successfully " + "."
    # from_email = EMAIL_HOST_USER
    # to = request.user.email
    # response = redirect("narration").url
    # path = request.build_absolute_uri(response)
    # context = {
    #     # "Name": user,
    #     "script_id": script_id,
    #     "script_name": script_title,
    #     "dual_dial": dual_dial_script,
    #     "dial_src_lang": dial_src_script,
    #     "dial_dest_lang": languages.get(dial_dest_lang),
    #     "non_dial_dest_lang": languages.get(non_dial_dest_lang),
    #     "non_dial_src_lang": languages.get(non_dial_src_lang),
    #     "dial_dest_script": dial_dest_script,
    #     "status": "Success",
    #     "path": path,
    # }
    # # "heading2": f"To view from blockchain use following details: Timestamp - {x.timestamp}, Key - {x.script_title}, Service - convertScript",
    # html_content = render_to_string(
    #     "conversion/email.html", context
    # )  # render with dynamic value
    # print(html_content, "this is a html content ****************** ")
    # # Strip the html tag. So people can see the pure text at least.
    # text_content = strip_tags(html_content)
    # # create the email, and attach the HTML version as well.
    # print("email process started")
    # msg = EmailMultiAlternatives(subject, text_content, from_email, [to])
    # msg.attach_alternative(html_content, "text/html")
    # msg.send()

    # print("after mail has been sent my context is", context)
    return JsonResponse({}, status=200)


# -> For Viewing Your Conversion
@login_required
def view_conversion_bkp(request):
    start_time = time.time()
    # get data from the blockchain for ppt
    if UserCredentialsForBlockchain.objects.filter(user=request.user).exists():
        try:
            ppt = []
            blockchain_obj = UserCredentialsForBlockchain.objects.get(
                user=request.user)
            projectIds = getUserprojectIds(blockchain_obj.user_id)
            # Print array values from the last element to the first
            ppt_all = len(projectIds)
            for i in range(len(projectIds) - 1, -1, -1):
                privatekey = blockchain_obj.privateKey
                user_id = blockchain_obj.user_id
                Project = projectIds[i]
                private_Key = decryptionOfPrivate(privatekey)
                status, getData = getPPTConversion(
                    private_Key.decode('utf-8'), user_id, Project)
                if status == True:
                    data1 = getData[1]
                    converted_dict = eval(data1)
                    download_file_System(converted_dict.get(
                        "ppt_scriptFile_hash"), converted_dict.get("ppt_scriptFile_path"))
                    download_file_System(converted_dict.get(
                        "translated_ppt_hash"), converted_dict.get("translated_ppt_path"))
                    converted_dict["vetted_file_url"]=decryptionOfUrl(converted_dict.get("vetted_file_hash"))
                    converted_dict["orginal_file_url"]=decryptionOfUrl(converted_dict.get("ppt_scriptFile_hash"))
                    converted_dict["translate_file_url"]=decryptionOfUrl(converted_dict.get("translated_ppt_hash"))

                    
                    ppt.append(converted_dict)

        except:
            ppt = pptconversion.objects.filter(
                user_id=request.user.id).order_by("-date_at")
            ppt_all = pptconversion.objects.filter(
                user_id=request.user.id).count()

    else:
        ppt = pptconversion.objects.filter(
            user_id=request.user.id).order_by("-date_at")
        ppt_all = pptconversion.objects.filter(user_id=request.user.id).count()

    if UserCredentialsForBlockchain.objects.filter(user=request.user).exists():
        obj = []
        blockchain_obj = UserCredentialsForBlockchain.objects.get(user=request.user)
        script_projectIds = scriptGetUserprojectIds(blockchain_obj.user_id)
        number = len(script_projectIds)
        for i in range(len(script_projectIds) - 1, -1, -1):
            privatekey = blockchain_obj.privateKey
            user_id =blockchain_obj.user_id
            Project= script_projectIds[i]
            private_Key = decryptionOfPrivate(privatekey)
            status,getData = getConversion(private_Key.decode('utf-8'),user_id,Project)
            if status == True:
                data1 = getData[1]
                converted_dict = eval(data1)
                # download_file_System(converted_dict.get("original_scriptFile_hash"),converted_dict.get("original_scriptFile_path"))
                # download_file_System(converted_dict.get("translated_scriptFile_hash"),converted_dict.get("translated_scriptFile_path"))
                converted_dict["original_scriptFile_url"]=viewDecryptionOfUrl(converted_dict.get("original_scriptFile_hash"))
                converted_dict["translated_scriptFile_url"]=viewDecryptionOfUrl(converted_dict.get("translated_scriptFile_hash"))
                converted_dict["translated_docxscriptFile_url"]=decryptionOfUrl(converted_dict.get("translated_docxscriptFile_hash"))
                obj.append(converted_dict)
    else:
        number = ReferUser.objects.filter(refferedBy=request.user).count()
        obj = MNFScriptDatabase.objects.filter(
            user_id=request.user).order_by("-date_at")
    # number = ReferUser.objects.filter(refferedBy=request.user).count()
    # obj = MNFScriptDatabase.objects.filter(
    #     user_id=request.user).order_by("-date_at")
    script_path = []
    pq = 0
    for i in obj:
        if i.get("translated_script_path")!= "":
            script_path.append(i.get("translated_script_path"))
            pq += 1

    script_is_vetted = []
    tasks = LPPTASKDatabase.objects.filter(user_id=request.user)
    for script in obj:
        script_is_vetted.append({"0": "0", "1": "", "2": script})
        for task in tasks:
            if task.translated_script:
                if script.get("script_id") == task.translated_script.script_id:
                    script_is_vetted[-1]["0"] = "1"
                    if task.outputfile:
                        script_is_vetted[-1]["1"] = task.outputfile
                    else:
                        if task.lppacceptancetime_dialogue and task.completiontime_action:
                            script_is_vetted[-1]["1"] = f"Vetting of your file will complete in {math.ceil((((task.deadlinetolpp_dialogue - tz.now()).total_seconds()) / 60 / 60) / 24)}"
                        elif task.lppacceptancetime_action:
                            script_is_vetted[-1]["1"] = f"Vetting of your file will complete in {math.ceil((((task.deadlinetolpp_action - tz.now()).total_seconds()) / 60 / 60) / 24)}"
                        else:
                            script_is_vetted[-1]["1"] = "Vetting of your file has not yet started"

    lenV = len(script_path)
    countOfScript = len(script_is_vetted)
    print(pq, script_is_vetted, script_path, "view conversion data99997")

    # -> Getting all Books

#  if UserCredentialsForBlockchain.objects.filter(user=request.user).exists():
    #     blockchain_obj = UserCredentialsForBlockchain.objects.get(user=request.user)
    #     projectIds = getUserprojectIds(blockchain_obj.user_id)
    #     for i in range(len(projectIds) - 1, -1, -1):
    #         privatekey = blockchain_obj.privateKey
    #         user_id =blockchain_obj.user_id
    #         Project= projectIds[i]
    #         private_Key = decryptionOfPrivate(privatekey)
    #         status,getData = getConversion(private_Key.decode('utf-8'),user_id,Project)
    #         if status == True:
    #             data1 = getData[1]
    #             converted_dict = eval(data1)
    #             download_file_System(converted_dict.get("original_bookFile_hash"),converted_dict.get("original_bookFile_path"))
    #             download_file_System(converted_dict.get("translated_bookFile_hash"),converted_dict.get("translated_bookFile_path"))
    # else:
    all_books = BookConversion.objects.filter(
        user_id=request.user).filter(translated_book_pdf__isnull=False).order_by("-date_at")

    # no_books = 0
    # for i in obj:
    #     if i.translated_book_pdf != "":
    #         no_books += 1

    # return render(
    #     request,
    #     "conversion/viewConvertedBooks.html",
    #     {"script_path": obj22, "pqw": pq2},
    # )
    print("rhis is data 777", ppt, "//////////********////////", ppt_all)
    end_time = time.time()
    print("-------------Taken Time for input processing->", end_time - start_time)
    return render(
        request,
        "conversion/stored_conversions.html",
        {
            "script_path": obj,
            "pq": pq,
            "number": number,
            "vettdata": script_is_vetted,
            "totalScript": countOfScript,
            "ppt": ppt,
            "ppt_all": ppt_all,
            "books": all_books,
            "number_books": len(all_books)
        },
    )


@login_required
def view_conversion(request):
    start_time = time.time()
    # get data from the blockchain for ppt
    # if UserCredentialsForBlockchain.objects.filter(user=request.user).exists():
    #     try:
    #         ppt = []
    #         blockchain_obj = UserCredentialsForBlockchain.objects.get(
    #             user=request.user)
    #         projectIds = getUserprojectIds(blockchain_obj.user_id)
    #         # Print array values from the last element to the first
    #         ppt_all = len(projectIds)
    #         for i in range(len(projectIds) - 1, -1, -1):
    #             privatekey = blockchain_obj.privateKey
    #             user_id = blockchain_obj.user_id
    #             Project = projectIds[i]
    #             private_Key = decryptionOfPrivate(privatekey)
    #             status, getData = getPPTConversion(
    #                 private_Key.decode('utf-8'), user_id, Project)
    #             if status == True:
    #                 data1 = getData[1]
    #                 converted_dict = eval(data1)
    #                 download_file_System(converted_dict.get(
    #                     "ppt_scriptFile_hash"), converted_dict.get("ppt_scriptFile_path"))
    #                 download_file_System(converted_dict.get(
    #                     "translated_ppt_hash"), converted_dict.get("translated_ppt_path"))
    #                 converted_dict["vetted_file_url"] = decryptionOfUrl(converted_dict.get("vetted_file_hash"))
    #                 converted_dict["orginal_file_url"] = decryptionOfUrl(converted_dict.get("ppt_scriptFile_hash"))
    #                 converted_dict["translate_file_url"] = decryptionOfUrl(converted_dict.get("translated_ppt_hash"))
    #
    #                 ppt.append(converted_dict)
    #
    #     except:
    #         ppt = pptconversion.objects.filter(
    #             user_id=request.user.id).order_by("-date_at")
    #         ppt_all = pptconversion.objects.filter(
    #             user_id=request.user.id).count()
    #
    # else:
    ppt = pptconversion.objects.filter(
        user_id=request.user.id).order_by("-date_at")
    ppt_all = pptconversion.objects.filter(user_id=request.user.id).filter(translated_ppt__isnull=False, translated_ppt__gt='').count()

    # if UserCredentialsForBlockchain.objects.filter(user=request.user).exists():
        # obj = []
        # blockchain_obj = UserCredentialsForBlockchain.objects.get(user=request.user)
        # script_projectIds = scriptGetUserprojectIds(blockchain_obj.user_id)
        # print("All Script Ids *********----->", script_projectIds)
        # number = len(script_projectIds)
        # for i in range(len(script_projectIds) - 1, -1, -1):
        #     privatekey = blockchain_obj.privateKey
        #     user_id = blockchain_obj.user_id
        #     Project = script_projectIds[i]
        #     private_Key = decryptionOfPrivate(privatekey)
        #     status, getData = getConversion(private_Key.decode('utf-8'), user_id, Project)
        #     if status == True:
        #         data1 = getData[1]
        #         converted_dict = eval(data1)
        #         # download_file_System(converted_dict.get("original_scriptFile_hash"),converted_dict.get("original_scriptFile_path"))
        #         # download_file_System(converted_dict.get("translated_scriptFile_hash"),converted_dict.get("translated_scriptFile_path"))
        #         converted_dict["original_scriptFile_url"] = viewDecryptionOfUrl(
        #             converted_dict.get("original_scriptFile_hash"))
        #         converted_dict["translated_scriptFile_url"] = viewDecryptionOfUrl(
        #             converted_dict.get("translated_scriptFile_hash"))
        #         converted_dict["translated_docxscriptFile_url"] = decryptionOfUrl(
        #             converted_dict.get("translated_docxscriptFile_hash"))
        #         obj.append(converted_dict)
    # else:
    number = ReferUser.objects.filter(refferedBy=request.user).count()
    # obj = MNFScriptDatabase.objects.filter(
    #     user_id=request.user).order_by("-date_at")
    obj = ScriptTranslations.objects.filter(
        user_id=request.user).order_by("-date_translated")
    # number = ReferUser.objects.filter(refferedBy=request.user).count()
    # obj = MNFScriptDatabase.objects.filter(
    #     user_id=request.user).order_by("-date_at")
    script_path = []
    pq = 0
    for i in obj:
        if i.translated_script_path != "":
            # script_path.append(i.get("translated_script_path"))
            pq += 1

    script_is_vetted = []
    tasks = LPPTASKDatabase.objects.filter(user_id=request.user)
    for script in obj:
        script_is_vetted.append({"0": "0", "1": "", "2": script, "3":""})
        for task in tasks:
            if task.translated_script:
                if script.translation_id == task.translated_script.translation_id:
                    script_is_vetted[-1]["0"] = "1"
                    if task.outputfile:
                        script_is_vetted[-1]["1"] = task.outputfile
                    else:
                        if task.lppacceptancetime_dialogue and task.completiontime_action:
                            script_is_vetted[-1][
                                "3"] = f"Vetting of your file will complete in {math.ceil((((task.deadlinetolpp_dialogue - tz.now()).total_seconds()) / 60 / 60) / 24)} day"
                        elif task.lppacceptancetime_action:
                            script_is_vetted[-1][
                                "3"] = f"Vetting of your file will complete in {math.ceil((((task.deadlinetolpp_action - tz.now()).total_seconds()) / 60 / 60) / 24)} day"
                        else:
                            script_is_vetted[-1]["3"] = "Vetting of your file has not yet started"

    # lenV = len(script_path)
    countOfScript = len(script_is_vetted)
    # print(pq, script_is_vetted, script_path, "view conversion data99997")

    # -> Getting all Books

    #  if UserCredentialsForBlockchain.objects.filter(user=request.user).exists():
    #     blockchain_obj = UserCredentialsForBlockchain.objects.get(user=request.user)
    #     projectIds = getUserprojectIds(blockchain_obj.user_id)
    #     for i in range(len(projectIds) - 1, -1, -1):
    #         privatekey = blockchain_obj.privateKey
    #         user_id =blockchain_obj.user_id
    #         Project= projectIds[i]
    #         private_Key = decryptionOfPrivate(privatekey)
    #         status,getData = getConversion(private_Key.decode('utf-8'),user_id,Project)
    #         if status == True:
    #             data1 = getData[1]
    #             converted_dict = eval(data1)
    #             download_file_System(converted_dict.get("original_bookFile_hash"),converted_dict.get("original_bookFile_path"))
    #             download_file_System(converted_dict.get("translated_bookFile_hash"),converted_dict.get("translated_bookFile_path"))
    # else:
    all_books = BookConversion.objects.filter(
        user_id=request.user).filter(translated_book_pdf__isnull=False).order_by("-date_at")

    # no_books = 0
    # for i in obj:
    #     if i.translated_book_pdf != "":
    #         no_books += 1

    # return render(
    #     request,
    #     "conversion/viewConvertedBooks.html",
    #     {"script_path": obj22, "pqw": pq2},
    # )
    # print("rhis is data 777", ppt, "//////////********////////", ppt_all)
    end_time = time.time()
    print("-------------Taken Time for input processing->", end_time - start_time)
    return render(
        request,
        "conversion/stored_conversions.html",
        {
            "script_path": obj,
            "pq": pq,
            "number": number,
            "vettdata": script_is_vetted,
            "totalScript": countOfScript,
            "ppt": ppt,
            "ppt_all": ppt_all,
            "books": all_books,
            "number_books": len(all_books)
        },
    )

def fetch_data_blockchain(request):
    if request.method == "POST":
        id = str(request.POST.get("id"))
        service = str(request.POST.get("service"))
        type_file = request.POST.get("type_file")
        decryptionFunc = decryptionOfUrl if request.POST.get("type_file") == "original" else viewDecryptionOfUrl
        if service == "Script":
            type_file = "original_scriptFile_hash" if type_file == "original" else \
                "translated_scriptFile_hash"
            try:
                if request.user == ScriptTranslations.objects.get(translation_id=str(id)).user_id:
                    blockchain_obj = UserCredentialsForBlockchain.objects.get(user=request.user)
                    privatekey = blockchain_obj.privateKey
                    user_id = blockchain_obj.user_id
                    private_Key = decryptionOfPrivate(privatekey)
                    status, getData = getConversion(private_Key.decode('utf-8'), user_id, str(id))
                    if status == True:
                        data1 = getData[1]
                        converted_dict = eval(data1)
                        print("Data Script ------------>",converted_dict)
                        # converted_dict["original_scriptFile_url"] = viewDecryptionOfUrl(
                        #     converted_dict.get("original_scriptFile_hash"))
                        # converted_dict["translated_scriptFile_url"] = viewDecryptionOfUrl(
                        #     converted_dict.get("translated_scriptFile_hash"))
                        # converted_dict["translated_docxscriptFile_url"] = decryptionOfUrl(
                        #     converted_dict.get("translated_docxscriptFile_hash"))
                        # decryptionFunc = decryptionOfUrl if request.POST.get("type_file") == "original" else viewDecryptionOfUrl
                        # if request.POST.get("type_file") == "original":
                        #     download_file_System(converted_dict.get(
                        #         "original_scriptFile_hash"), converted_dict.get("original_scriptFile_path"))
                        file_name = None
                        if request.POST.get("type_file") == "original":
                            file_name = str((str(converted_dict['original_scriptFile_path']).split("/"))[-1])
                            file_link = str(decryptionFunc(converted_dict.get(str(type_file)))) + "/" + str(file_name)
                        else:
                            file_link = str(decryptionFunc(converted_dict.get(str(type_file))))

                        return JsonResponse({"status":True, "download_link": file_link, "file_name": str(file_name)})
                    else:
                        try:
                            current_datetime = datetime.datetime.now()
                            if UserCredentialsForBlockchain.objects.filter(user=request.user).exists():
                                print("blockchain script conversion 2")
                                obj = ScriptTranslations.objects.get(translation_id=id)
                                obj2 = MNFScriptDatabase.objects.get(script_id=obj.script_link_id)
                                temp1 = (str(obj2.script_file_path).split("media/"))[1]
                                temp2 = str(obj.translated_script_path)
                                uploaded_script = f"{basePath}/media/{temp1}"
                                translated_script = f"{basePath}{temp2}"
                                scriptconversion = {}
                                print("blockchain script conversion 3")
                                with open(uploaded_script, 'rb') as f:
                                    hash = uploadDataToIPFSNode(f)
                                    scriptconversion["original_scriptFile_hash"] = hash
                                scriptconversion["original_scriptFile_path"] = uploaded_script
                                scriptconversion["date_at"] = current_datetime.strftime(
                                    "%Y-%m-%d %H:%M:%S")
                                print("blockchain script conversion 4")
                                with open(translated_script, 'rb') as f1:
                                    hash = uploadDataToIPFSNode(f1)
                                    scriptconversion["translated_scriptFile_hash"] = hash
                                scriptconversion["translated_scriptFile_path"] = translated_script
                                # docx_file_path = translated_script.replace(".pdf", ".docx")
                                # docxfile_name = docx_file_path.split("/")[-1]
                                # docxfile_name ="translate_docx_file.docx"
                                #
                                # with open(docx_file_path, 'rb') as f2:
                                #     hash1 = uploadDataToIPFSNode(f2)
                                #     scriptconversion["translated_docxscriptFile_hash"] = hash1
                                # scriptconversion["docxfile_name"] = docxfile_name
                                print("blockchain script conversion 5")
                                blockchain_obj = UserCredentialsForBlockchain.objects.get(
                                    user=request.user)
                                UserId = blockchain_obj.user_id
                                Project = request.session.get('translation_id', None)
                                Data = str(scriptconversion)
                                userPrivateKey = blockchain_obj.privateKey
                                userkey = decryptionOfPrivate(userPrivateKey)
                                # hash1 = UploadConversionData(OWNER_KEY,blockchain_obj.publicKey, UserId, str(Project), Data)
                                # transaction_hash = UploadConversionData(tx_id)
                                tx_id = UploadConversionData(OWNER_KEY, blockchain_obj.publicKey, UserId, str(Project),
                                                             Data)
                                print("blockchain script conversion 6")
                                print("scriptconversion hash >>>>>>>>>>>>>>>", hash)
                                certificatepath = certificateGenrate(request.user.username, "script conversion", hash)
                                hash = hash_decrypation(hash)
                                to_email = [request.user.email]
                                email_code = 'BL1'
                                key_value = {
                                    "service": "script conversion",
                                    "hash": hash,
                                    "public key": blockchain_obj.publicKey,
                                    "private key": userkey.decode('utf-8'),
                                    "Transaction Hash": tx_id
                                }
                                sendmail(to_email=to_email, email_code=email_code, key_value=key_value,
                                         filePath=certificatepath)

                                file_name = None
                                if request.POST.get("type_file") == "original":
                                    file_name = str((str(scriptconversion['original_scriptFile_path']).split("/"))[-1])
                                    file_link = str(decryptionFunc(scriptconversion.get(str(type_file)))) + "/" + str(
                                        file_name)
                                else:
                                    file_link = str(decryptionFunc(scriptconversion.get(str(type_file))))

                                return JsonResponse(
                                    {"status": True, "download_link": file_link, "file_name": str(file_name)})
                        except Exception as e:
                            print("Error is----------------*******************:", e)
                            return JsonResponse({"status": False})
            except Exception as e:
                try:
                    current_datetime = datetime.datetime.now()
                    if UserCredentialsForBlockchain.objects.filter(user=request.user).exists():
                        print("blockchain script conversion 2")
                        obj = ScriptTranslations.objects.get(translation_id=id)
                        obj2 = MNFScriptDatabase.objects.get(script_id=obj.script_link_id)
                        temp1 = (str(obj2.script_file_path).split("media/"))[1]
                        temp2 = str(obj.translated_script_path)
                        uploaded_script = f"{basePath}/media/{temp1}"
                        translated_script = f"{basePath}{temp2}"
                        scriptconversion = {}
                        print("blockchain script conversion 3")
                        with open(uploaded_script, 'rb') as f:
                            hash = uploadDataToIPFSNode(f)
                            scriptconversion["original_scriptFile_hash"] = hash
                        scriptconversion["original_scriptFile_path"] = uploaded_script
                        scriptconversion["date_at"] = current_datetime.strftime(
                            "%Y-%m-%d %H:%M:%S")
                        print("blockchain script conversion 4")
                        with open(translated_script, 'rb') as f1:
                            hash = uploadDataToIPFSNode(f1)
                            scriptconversion["translated_scriptFile_hash"] = hash
                        scriptconversion["translated_scriptFile_path"] = translated_script
                        # docx_file_path = translated_script.replace(".pdf", ".docx")
                        # docxfile_name = docx_file_path.split("/")[-1]
                        # docxfile_name ="translate_docx_file.docx"
                        #
                        # with open(docx_file_path, 'rb') as f2:
                        #     hash1 = uploadDataToIPFSNode(f2)
                        #     scriptconversion["translated_docxscriptFile_hash"] = hash1
                        # scriptconversion["docxfile_name"] = docxfile_name
                        print("blockchain script conversion 5")
                        blockchain_obj = UserCredentialsForBlockchain.objects.get(
                            user=request.user)
                        UserId = blockchain_obj.user_id
                        Project = request.session.get('translation_id', None)
                        Data = str(scriptconversion)
                        userPrivateKey = blockchain_obj.privateKey
                        userkey = decryptionOfPrivate(userPrivateKey)
                        # hash1 = UploadConversionData(OWNER_KEY,blockchain_obj.publicKey, UserId, str(Project), Data)
                        # transaction_hash = UploadConversionData(tx_id)
                        tx_id = UploadConversionData(OWNER_KEY, blockchain_obj.publicKey, UserId, str(Project), Data)
                        print("blockchain script conversion 6")
                        print("scriptconversion hash >>>>>>>>>>>>>>>", hash)
                        certificatepath = certificateGenrate(request.user.username, "script conversion", hash)
                        hash = hash_decrypation(hash)
                        to_email = [request.user.email]
                        email_code = 'BL1'
                        key_value = {
                            "service": "script conversion",
                            "hash": hash,
                            "public key": blockchain_obj.publicKey,
                            "private key": userkey.decode('utf-8'),
                            "Transaction Hash": tx_id
                        }
                        sendmail(to_email=to_email, email_code=email_code, key_value=key_value,
                                 filePath=certificatepath)

                        file_name = None
                        if request.POST.get("type_file") == "original":
                            file_name = str((str(scriptconversion['original_scriptFile_path']).split("/"))[-1])
                            file_link = str(decryptionFunc(scriptconversion.get(str(type_file)))) + "/" + str(file_name)
                        else:
                            file_link = str(decryptionFunc(scriptconversion.get(str(type_file))))

                        return JsonResponse({"status": True, "download_link": file_link, "file_name": str(file_name)})
                except Exception as e:
                    print("Error is----------------*******************:",e)
                    return JsonResponse({"status": False})


        elif service == "PPT":
            type_file = "ppt_scriptFile_hash" if type_file == "original" else \
                "vetted_file_hash" if type_file == "vetted" else "translated_ppt_hash"
            try:
                if request.user == pptconversion.objects.get(ppt_id=str(id)).user_id:
                    blockchain_obj = UserCredentialsForBlockchain.objects.get(user=request.user)
                    privatekey = blockchain_obj.privateKey
                    user_id = blockchain_obj.user_id
                    private_Key = decryptionOfPrivate(privatekey)
                    status, getData = getPPTConversion(private_Key.decode('utf-8'), user_id, str(id))
                    if status == True:
                        data1 = getData[1]
                        converted_dict = eval(data1)
                        file_link = str(decryptionOfUrl(converted_dict.get(str(type_file))))
                        file_name = file_name = str((str(converted_dict['ppt_scriptFile_path']).split("/"))[-1]) if request.POST.get("type_file") == "original" else str((str(converted_dict['translated_ppt_path']).split("/"))[-1])
                        return JsonResponse({"status": True, "download_link": file_link + "/" + str(file_name), "file_name":str(file_name)})
                    else:
                        return JsonResponse({"status": False})
            except Exception as e:

                print("Error is----------------*******************:", e)
                return JsonResponse({"status": False})

    return HttpResponse("Get Request Not Allowed")


# -> For Deleting your Conversion
def delete_script(request, id):
    script_name = (((str(ScriptTranslations.objects.get(
        translation_id=id).script_link_id.script_file_path).split("/"))[-1]).split("."))[0]
    obj = ScriptTranslations.objects.get(translation_id=id)
    if UserCredentialsForBlockchain.objects.filter(user=request.user).exists():
        blockchain_obj = UserCredentialsForBlockchain.objects.get(user=request.user)
        userkey =decryptionOfPrivate(blockchain_obj.privateKey)
        print("function is calling.......",userkey.decode('utf-8'),blockchain_obj.user_id,obj.translation_id)
        deleteConversion(OWNER_KEY,blockchain_obj.publicKey,blockchain_obj.user_id,obj.translation_id)

    obj.delete()


    to = request.user.email
    key_value = {
        "User": request.user.username,
        "script_name": str(script_name)
    }
    sendmail(to_email=[to], email_code="PP20", key_value=key_value)
    return HttpResponseRedirect("/conversion/view_conversion")


# -> Feedback on Conversion by User
def feedback_user(request):
    if request.method == "POST":
        x = ScriptTranslations.objects.get(translation_id=request.POST.get("mnfscriptid"))
        if str(request.POST.get("text")) == " " or str(request.POST.get("text")) == "":
            x.attention_feedback = ""
        else:
            x.attention_feedback = str(request.POST.get("text"))
        if str(request.POST.get("text2")) == " " or str(request.POST.get("text2")) == "":
            x.error_faced_feedback = ""
        else:
            x.error_faced_feedback = str(request.POST.get("text2"))
        if str(request.POST.get("text3")) == " " or str(request.POST.get("text3")) == "":
            x.improvement_feedback = ""
        else:
            x.improvement_feedback = str(request.POST.get("text3"))
        if request.POST.get("rating") == " " or request.POST.get("rating") == "":
            x.exp_rate = 0
        else:
            x.exp_rate = int(request.POST.get("rating"))
        if request.POST.get("rating2") == " " or request.POST.get("rating2") == "":
            x.content_accuracy_rate = 0
        else:
            x.content_accuracy_rate = int(request.POST.get("rating3"))
        if request.POST.get("rating3") == " " or request.POST.get("rating3") == "":
            x.translation_accuracy_rate = 0
        else:
            x.translation_accuracy_rate = int(request.POST.get("rating2"))
        x.save()
        return redirect("view_conversion")


# -> For Demo of Conversion
def demo(request):
    number = ReferUser.objects.filter(refferedBy=request.user).count()
    return render(request, "conversion/demo.html", {"number": number})


# -> Some Random Function
def announce(request):
    message = ""
    user = User.objects.all()
    cUser = request.user
    if cUser.is_superuser == True:
        if request.method == "POST":
            notification = request.POST.get("message")
            for i in user:
                var = Notifications(user_id=i, notification=notification)
                var.save()
            messgae = "notification sent successfull."
            return render(request, "conversion/announce.html", {"message": message})
        else:
            return render(request, "conversion/announce.html", {})
    else:
        message = " you need to be superuser"
        return render(request, "conversion/announce.html", {"message": message})


# -> Conversion Checkout
def conversionCheckout(request):
    # new payment 8000
    set_payment_token(request)
    keyID = request.session["keyID"]
    keySecret = request.session["keySecret"]
    if request.method == "POST":
        for key, value in request.session.items():
            print('{} => {}'.format(key, value))
        if request.POST.get("want_to_be_vetted") == "YES":
            request.session["want_to_be_vetted"] = "on"
        else:
            request.session["want_to_be_vetted"] = request.POST.get(
                "want_to_be_vetted")
        total_amount = request.session["amount"]
        total_amount1 = request.session["subtotal"]
        # amount_charged = request.session["amount"]
        amount_discount = request.session["discount"]
        request.session["pay_with_wallet"] = "no"
        request.session["amount_before_pay_wallet"] = total_amount


        # is he instituitional student or not
        if request.session.get("student_discount_calculate") == "Yes":
            from institutional.models import AffiliatedStudent, UnaffiliatedStudent, WaitForInstituteStudent
            user = User.objects.get(pk=request.user.id)
            if UnaffiliatedStudent.objects.filter(user=user).exists():
                user = UnaffiliatedStudent.objects.get(user=user)
                if user.free_credits >= total_amount:

                    user.free_credits -= total_amount
                    user.save()
                    context = {
                        "mode": "Institutional User",
                    }
                    return JsonResponse(context)

                elif user.free_credits < total_amount:

                    total_amount -= user.free_credits
                    user.free_credits = 0
                    user.save()


            elif WaitForInstituteStudent.objects.filter(user=user).exists():
                user = WaitForInstituteStudent.objects.get(user=user)
                if user.free_credits >= total_amount:

                    user.free_credits -= total_amount
                    user.save()
                    context = {
                        "mode": "Institutional User",
                    }
                    return JsonResponse(context)

                elif user.free_credits < total_amount:

                    total_amount -= user.free_credits
                    user.free_credits = 0
                    user.save()


                return True
            elif AffiliatedStudent.objects.filter(user=user).exists():
                user = AffiliatedStudent.objects.get(user=user)
                if user.free_credits >= total_amount:

                    user.free_credits -= total_amount
                    user.save()
                    context = {
                        "mode": "Institutional User",
                    }
                    return JsonResponse(context)

                elif user.free_credits < total_amount:

                    total_amount -= user.free_credits
                    user.free_credits = 0
                    user.save()



        try:
            print("pay_wallet it is", request.POST.get("pay_wallet"))
            if request.POST.get("pay_wallet") == "true":
                request.session["pay_with_wallet"] = "yes"
                with open(f"{basePath}/MNF/json_keys/conversionRates.json") as c:
                    curr = json.load(c)
                    print(curr["rates"]["INR"])
                    try:
                        rate = curr["rates"]["INR"]
                    except Exception as e:
                        print("checkout error", e)
                        rate = 80
                print("Checking Wallet")
                wall = Wallet.objects.get(user=request.user)
                print("this is walet", wall.balance)
                print(wall.balance)
                if wall.balance >= (total_amount * rate):
                    print("wallet if hai")
                    # wall.balance = wall.balance - (total_amount * rate)
                    # wall.save()
                    request.session["pay_wallet_deduction"] = round(total_amount * rate, 2)
                    total_amount = 0

                else:
                    print("wallet else hai")
                    # wall.balance = 0
                    # wall.save()
                    request.session["pay_wallet_deduction"] = round(wall.balance, 2)
                    total_amount = round((round(total_amount * rate, 2) - round(wall.balance, 2)) / rate, 2)
                # request.session["fbalance"] = float(
                #     wall.balance) - float(balance*rate)
                # request.session["amount"] = total_amount
                # total_amount = request.session["amount"]
        except Exception as e:
            print("Error is:",e)
            pass
        request.session["amount"] = total_amount

        services_used = 2 if request.session["want_to_be_vetted"] == "on" else 1
        context = create_indent(request, 'Conversion', str(
            request.session["script_id"]), services_used, '', total_amount1, total_amount, amount_discount)
        print("Create indent 9987", context)
        for key, value in request.session.items():
            print('{} => {}'.format(key, value))
        print(str(request.session["script_id"]))
        # instance = MNFScriptDatabase.objects.get(script_id=str(request.session["script_id"]))
        with open(f"{basePath}/MNF/json_keys/conversionRates.json") as c:
            curr = json.load(c)
            try:
                rate = curr["rates"]["INR"]
            except Exception as e:
                rate = 80

        request.session["CurrencyRate"] = rate
        centralPayment_instance = CentralPayment.objects.get(
            id=context["central_pay_id"])

        # handle razor pay gateway →
        if "orderId" in context:
            # instance.payment_order_id = context["orderId"]
            # instance.central_payment_id = context["central_pay_id"]
            # instance.save()  # save central payment details in your database
            request.session["payment_order_id"] = context["orderId"]
            request.session["central_payment_id"] = context["central_pay_id"]

            pid = centralPayment_instance.order_id
            amtINR = round(centralPayment_instance.amount_charged * rate, 2)

            context = {
                "mode": "RazorPay",
                "pk": keyID,
                "amtINR": amtINR,
                "pid": pid,
                "amount": centralPayment_instance.amount_charged,
            }
            return JsonResponse(context)
            # return render(request, "conversion/checkoutC_RazorPay.html", context)

        # handle stripe gateway →
        elif "client_secret" in context:
            # save central payment details in your database
            request.session["payment_order_id"] = context["client_secret"]
            request.session["central_payment_id"] = context["central_pay_id"]

            amtINR = round(centralPayment_instance.amount_charged * rate, 2)
            context = {
                "mode": "Stripe",
                "pk": context["pub_key"],
                "total_amount": centralPayment_instance.amount_charged,
                "secret_key": context["client_secret"],
                "amtINR": amtINR,

            }
            return JsonResponse(context)

        # handle corporate profile →
        elif "monthly_user" in context:
            # instance.payment_order_id = "corporate profile"
            # instance.central_payment_id = "corporate profile"
            # instance.save()

            # script_id = request.session["script_id"]
            # script_title = request.session["script_title"]
            # script_file_path = request.session["script_file_path"]
            # dial_conv_script = request.session["dial_conv_script"]
            # nondial_dest_language = request.session["nondial_dest_language"]
            # dial_dest_language = request.session["dial_dest_language"]
            # dial_dest_script = request.session["dial_dest_script"]
            # dial_src_lang = request.session["dial_src_lang"]
            # non_dial_src_lang = request.session["non_dial_src_lang"]
            # dial_src_script = request.session["dial_src_script"]
            # non_dial_src_script = request.session["non_dial_src_script"]
            # dual_dial_script = request.session["dual_dial_script"]
            # nondial_dest_script = request.session["nondial_dest_script"]
            # if request.session.get("want_to_be_vetted") != "NO":
            #     total_amount = request.session["lppamount"]
            # else:
            #     total_amount = request.session["amount"]
            # to_be_vetted_by_lpp = request.session["want_to_be_vetted"]
            # option3 = request.session["option3"]
            # option4 = request.session["option4"]
            # option5 = request.session["option5"]
            # option6 = request.session["option6"]
            # # payment_intent_id = request.session["payment_intent_id"]
            # # pi = stripe.PaymentIntent.retrieve(payment_intent_id)
            # try:
            #     s = MNFScriptDatabase.objects.get(user_id = request.user, script_id = script_id)
            # except:
            #     s = MNFScriptDatabase()
            #     s.user_id = request.user
            #     s.script_id = script_id
            # s.script_title = script_title
            # s.author_name = request.user.first_name
            # # s.dial_dest_language = dial_dest_language
            # # s.dial_dest_script = dial_dest_script
            # # s.nondial_dest_language = nondial_dest_language
            # # s.dual_dial_script = dual_dial_script
            # s.script_file_path = script_file_path
            # # save central payment details in your database
            # # s.payment_order_id = "monthly_user"
            # # s.central_payment_id = context["central_pay_id"]
            # # s.payment_intent_id = payment_intent_id
            # s.nondial_src_script = non_dial_src_script
            # s.dial_src_script = dial_src_script
            # s.dial_src_language = dial_src_lang
            # s.nondial_src_language = non_dial_src_lang
            # # s.nondial_dest_script = nondial_dest_script
            # s.save()
            #
            # translation_instance = ScriptTranslations()
            # translation_instance.user_id = request.user
            # translation_instance.script_link_id = s
            # translation_instance.nondial_dest_language = nondial_dest_language
            # translation_instance.nondial_dest_script = nondial_dest_script
            # translation_instance.dial_dest_language = language_2_code[str(dial_dest_language)]
            # translation_instance.dial_dest_script = dial_dest_script
            # translation_instance.dual_dial_script = dual_dial_script
            # translation_instance.payment_order_id = "monthly_user"
            request.session['central_pay_id'] = context["central_pay_id"]


            context = {
                "mode": "Corporate User",
            }
            # return redirect('conversion')
            return JsonResponse(context)
            # return render(request, "conversion/thanksconversion.html", context)

        # if request.POST.get("country") == "IN":
        #
        #     # try: -> Old WAy of Getting Conversion Rates between Currencies
        #     #     c = CurrencyRates()
        #     #     rate = c.get_rate("USD", "INR")
        #     # except:
        #     #     rate = 80
        #     with open(f"{basePath}/MNF/json_keys/conversionRates.json") as c:
        #         curr = json.load(c)
        #         print(curr["rates"]["INR"])
        #         try:
        #             rate = curr["rates"]["INR"]
        #             print(rate, " : Latest rates 30sep")
        #             # c = CurrencyRates()
        #             # rate = c.get_rate("USD", str(currency.upper()))
        #         except Exception as e:
        #             print("checkout error", e)
        #             rate = 80
        #
        #     amtINR = round(float(float(total_amount) * rate), 2)
        #     client = razorpay.Client(auth=(keyID, keySecret))
        #     payment_intent = client.order.create(
        #         {
        #             "amount": int(float(total_amount) * 100 * rate),
        #             "currency": "INR",
        #             "payment": {
        #                 "capture": "automatic",
        #                 "capture_options": {"refund_speed": "normal"},
        #             },
        #         }
        #     )

        # else:

            # try: -> Old WAy of Getting Conversion Rates between Currencies
            #     c = CurrencyRates()
            #     rate = c.get_rate("USD", "INR")
            # except:
            #     rate = 80
            # with open(f"{basePath}/MNF/json_keys/conversionRates.json") as c:
            #     curr = json.load(c)
            #     print(curr["rates"]["INR"])
            #     try:
            #         rate = curr["rates"]["INR"]
            #         print(rate, " : Latest rates 30sep")
            #         # c = CurrencyRates()
            #         # rate = c.get_rate("USD", str(currency.upper()))
            #     except Exception as e:
            #         print("checkout error", e)
            #         rate = 80
            #
            # amtINR = round(float(float(total_amount) * rate), 2)
            # payment_intent = stripe.PaymentIntent.create(
            #     amount=int(float(total_amount) * 100 * rate),
            #     currency="INR",
            #     payment_method_types=["card"],
            # )
            # request.session["CurrencyRate"] = rate
            # request.session["payment_intent_id"] = payment_intent.id
            # context = {
            #     "pk": STRIPE_PUB_KEY,
            #     "total_amount": total_amount,
            #     "amtINR": amtINR,
            # }
            # return render(request, "conversion/checkoutC.html", context)


# ppt checkout
# -> Conversion Checkout
def pptCheckout(request):
    set_payment_token(request)
    keyID = request.session["keyID"]
    keySecret = request.session["keySecret"]

    if request.method == "POST":
        if request.POST.get("want_to_be_vetted") == "yes":
            # total_amount = request.session["pptamount"]
            request.session["want_to_be_vetted"] = "on"
        else:
            request.session["want_to_be_vetted"] = "off"
        total_amount = request.session['amount']
        total_amount1 = request.session['subtotal']
        amount_discount = request.session["discount"]
        request.session["pay_with_wallet"] = "no"
        request.session["amount_before_pay_wallet"] = total_amount
        try:
            if request.POST.get("pay_wallet") == "on":
                request.session["pay_with_wallet"] = "yes"
                with open(f"{basePath}/MNF/json_keys/conversionRates.json") as c:
                    curr = json.load(c)
                    print(curr["rates"]["INR"])
                    try:
                        rate = curr["rates"]["INR"]
                    except Exception as e:
                        print("checkout error", e)
                        rate = 80

                wall = Wallet.objects.get(user=request.user)
                print("this is walet", wall.balance)
                print(wall.balance)
                if wall.balance >= (total_amount * rate):
                    print("wallet if hai") 
                    request.session["pay_wallet_deduction"] = round(total_amount * rate, 2)
                    total_amount = 0

                else:
                    print("wallet else hai")
                    request.session["pay_wallet_deduction"] = round(wall.balance, 2)
                    total_amount = round((round(total_amount * rate, 2) - round(wall.balance, 2)) / rate, 2)

                # balance = float(request.POST["balance"])
                # payable = float(request.POST["payable"])
                # wall = Wallet.objects.get(user=request.user)
                # request.session["fbalance"] = float(
                #     wall.balance) - float(balance*rate)
                # wall.save()
                # request.session["amount"] = payable
                # total_amount = request.session["amount"]
        except Exception as e:
            print("checkout error", e)
            pass

            # call central payment function --> create indent
            # Next follow central payment docs...
            # if indian --> orderID --> razorpay gateway
            # non-indian --> client secret --> stripe
        request.session["amount"] = total_amount
        # total_amount1 = request.session["total_amount1"]
        # amount_charged = request.session["amount1"]
        # amount_discount = request.session["discount1"]

        services_used = 2 if request.session["want_to_be_vetted"] == "on" else 1
        context = create_indent(request, 'Conversion', str(request.session["ppt_id"]), services_used, '',
                                total_amount1, total_amount, amount_discount)
        print("Create indent bhaalu aa rhaha hai 7878", context)
        # instance = MNFScriptDatabase.objects.get(script_id=str(request.session["script_id"]))
        with open(f"{basePath}/MNF/json_keys/conversionRates.json") as c:
            curr = json.load(c)
            try:
                rate = curr["rates"]["INR"]
            except Exception as e:
                rate = 80

        request.session["CurrencyRate"] = rate
        centralPayment_instance = CentralPayment.objects.get(
            id=context["central_pay_id"])

        # handle razor pay gateway →
        if "orderId" in context:
            # instance.payment_order_id = context["orderId"]
            # instance.central_payment_id = context["central_pay_id"]
            # instance.save()  # save central payment details in your database
            request.session["payment_order_id"] = context["orderId"]
            request.session["central_payment_id"] = context["central_pay_id"]

            pid = centralPayment_instance.order_id
            amtINR = centralPayment_instance.amount_charged * rate

            context = {
                "mode": "RazorPay",
                "pk": keyID,
                "amtINR": amtINR,
                "pid": pid,
                "amount": centralPayment_instance.amount_charged,
            }
            return JsonResponse(context)
            # return render(request, "conversion/checkoutPPT_RazorPay.html", context)

        # handle stripe gateway →
        elif "client_secret" in context:
            request.session["payment_order_id"] = context[
                "client_secret"]  # save central payment details in your database
            request.session["central_payment_id"] = context["central_pay_id"]

            amtINR = centralPayment_instance.amount_charged * rate
            context = {
                "mode": "Stripe",
                "pk": context["pub_key"],
                "total_amount": centralPayment_instance.amount_charged,
                "secret_key": context["client_secret"],
                "amtINR": amtINR,
            }
            return JsonResponse(context)
            # return render(request, "conversion/checkoutPPT_Stripe.html", context)

        # handle corporate profile →
        elif "monthly_user" in context:
            ppt_instance = pptconversion.objects.get(
                ppt_id=request.session["ppt_id"])
            ppt_instance.central_payment_id = context["central_pay_id"]
            ppt_instance.payment_order_id = "monthly_user"
            ppt_instance.save()
            sendmail(to_email=[ppt_instance.user_id.email], email_code='CP4')
            sendmail(to_email=[ppt_instance.user_id.email], email_code='CP10')
            ppt_conversion(request.session["ppt_id"], request).start()
            sendmail(to_email=[ppt_instance.user_id.email], email_code='CP9')
            print('line---(1527)')
            print('is the email working for ppt')
            context = {
                "mode": "Corporate User"
            }
            return JsonResponse(context)
            # return render(request, "conversion/thanksppt.html")
            # instance.payment_order_id = "corporate profile"
            # instance.central_payment_id = "corporate profile"
            # instance.save()

            # return render(request, "conversion/thanksbook.html", {"book_id": request.session["book_id"]})

        # context = create_indent(request, 'Convert a ppt', sr.data["ppt_id"], 1, '', amount, sr.data["amount"], sr.data["discount"])
        # instance
        # # if request.POST.get("country") == "IN":
        # if "orderId" in context:
        #     return render(request, "conversion/checkoutPPT_RazorPay.html", context)
        # elif "client_secret" in context:
        #     return render(request, "conversion/checkoutPPT_Stripe.html", context)
        # elif "monthly_user" in context:
        #     pass
        # else:
        #     return Response({"message": "invalid request!"}, status=status.HTTP_400_BAD_REQUEST)

        # if request.POST.get("country") == "IN":

        #     # try: -> Old WAy of Getting Conversion Rates between Currencies
        #     #     c = CurrencyRates()
        #     #     rate = c.get_rate("USD", "INR")
        #     # except:
        #     #     rate = 80
        #     with open(f"{basePath}/MNF/json_keys/conversionRates.json") as c:
        #         curr = json.load(c)
        #         print(curr["rates"]["INR"])
        #         try:
        #             rate = curr["rates"]["INR"]
        #             print(rate, " : Latest rates 30sep")
        #             # c = CurrencyRates()
        #             # rate = c.get_rate("USD", str(currency.upper()))
        #         except Exception as e:
        #             print("checkout error", e)
        #             rate = 80

        #     amtINR = round(float(float(total_amount) * rate), 2)
        #     client = razorpay.Client(auth=(keyID, keySecret))
        #     payment_intent = client.order.create(
        #         {
        #             "amount": int(float(total_amount) * 100 * rate),
        #             "currency": "INR",
        #             "payment": {
        #                 "capture": "automatic",
        #                 "capture_options": {"refund_speed": "normal"},
        #             },
        #         }
        #     )
        #     request.session["CurrencyRate"] = rate
        #     pid = payment_intent["id"]
        #     context = {
        #         "pk": keyID,
        #         "amtINR": amtINR,
        #         "pid": pid,
        #         "amount": total_amount,
        #     }
        #     return render(request, "conversion/checkoutPPT_RazorPay.html", context)

        # else:

        #     # try: -> Old WAy of Getting Conversion Rates between Currencies
        #     #     c = CurrencyRates()
        #     #     rate = c.get_rate("USD", "INR")
        #     # except:
        #     #     rate = 80
        #     with open(f"{basePath}/MNF/json_keys/conversionRates.json") as c:
        #         curr = json.load(c)
        #         print(curr["rates"]["INR"])
        #         try:
        #             rate = curr["rates"]["INR"]
        #             print(rate, " : Latest rates 30sep")
        #             # c = CurrencyRates()
        #             # rate = c.get_rate("USD", str(currency.upper()))
        #         except Exception as e:
        #             print("checkout error", e)
        #             rate = 80

        #     amtINR = round(float(float(total_amount) * rate), 2)
        #     payment_intent = stripe.PaymentIntent.create(
        #         amount=int(float(total_amount) * 100 * rate),
        #         currency="INR",
        #         payment_method_types=["card"],
        #     )
        #     request.session["CurrencyRate"] = rate
        #     request.session["payment_intent_id"] = payment_intent.id
        #     context = {
        #         "pk": STRIPE_PUB_KEY,
        #         "total_amount": total_amount,
        #         "amtINR": amtINR,
        #     }
        #     return render(request, "conversion/checkoutPPT_Stripe.html", context)
    # return render(request, "conversion/conversion.html")


# "16 Nov file path", output_dir
# "16 Nov part 2 inside if"
# Path DNE inside if
# "Path 16 Nov", output_dir
# Class object instantiated

# -> Conversion Checkout
@login_required
def conversioncard(request):
    if request.method == "POST":
        # payment_method_id = request.POST["payment_method_id"]
        # payment_intent_id = request.session["payment_intent_id"]
        #
        # customer = stripe.Customer.create(
        #     email=request.user.email,
        #     payment_method=payment_method_id,
        #     invoice_settings={"default_payment_method": payment_method_id},
        # )
        #
        # stripe.PaymentIntent.modify(
        #     payment_intent_id, payment_method=payment_method_id, customer=customer.id
        # )
        # ret = stripe.PaymentIntent.confirm(payment_intent_id)
        # pi = stripe.PaymentIntent.retrieve(payment_intent_id)
        # if ret.status == "requires_action":
        customer = stripe.Customer.create(
            email=request.user.email,
        )
        payment_intent = stripe.PaymentIntent.create(
            amount=int(float(total_amount) * 100 * rate),
            currency="INR",
            automatic_payment_methods={"enabled": True},
            customer=customer.id,
        )
        pid = payment_intent.id
        request.session["payment_intent_id"] = pid
        context = {
            "pid": pid,
            "amtINR": amtINR,
            "secret_key": payment_intent.client_secret,
            "total_amount": total_amount,
            "STRIPE_PUBLISHABLE_KEY": STRIPE_PUB_KEY,
            "pk": STRIPE_PUB_KEY,
        }
        # context = {
        #     "pk": STRIPE_PUB_KEY,
        #     "pid":,
        #     "payment_intent_secret": request.session["payment_order_id"],
        # }
        return render(request, "conversion/3dsecuredConversion.html", context)
        # return render(request, "payments/paymentdone.html")


@login_required
def Bookcard(request):
    if request.method == "POST":
        payment_method_id = request.POST["payment_method_id"]
        payment_intent_id = request.session["payment_intent_id"]

        customer = stripe.Customer.create(
            email=request.user.email,
            payment_method=payment_method_id,
            invoice_settings={"default_payment_method": payment_method_id},
        )

        stripe.PaymentIntent.modify(
            payment_intent_id, payment_method=payment_method_id, customer=customer.id
        )
        ret = stripe.PaymentIntent.confirm(payment_intent_id)
        pi = stripe.PaymentIntent.retrieve(payment_intent_id)
        if ret.status == "requires_action":
            context = {
                "pk": STRIPE_PUB_KEY,
                "payment_intent_secret": pi.client_secret,
            }
            return render(request, "conversion/3dsecuredBook.html", context)
        return render(request, "payments/paymentdone.html")


def paymentDoneC_corporate(request):
    if request.method == "GET":

        script_id = request.session["script_id"]
        script_title = request.session["script_title"]
        script_file_path = request.session["script_file_path"]
        dial_conv_script = request.session["dial_conv_script"]
        nondial_dest_language = request.session["nondial_dest_language"]
        dial_dest_language = request.session["dial_dest_language"]
        dial_dest_script = request.session["dial_dest_script"]
        dial_src_lang = request.session["dial_src_lang"]
        non_dial_src_lang = request.session["non_dial_src_lang"]
        dial_src_script = request.session["dial_src_script"]
        non_dial_src_script = request.session["non_dial_src_script"]
        dual_dial_script = request.session["dual_dial_script"]
        nondial_dest_script = request.session["nondial_dest_script"]
        if request.session.get("want_to_be_vetted") != "NO":
            total_amount = request.session["lppamount"]
        else:
            total_amount = request.session["amount"]
        to_be_vetted_by_lpp = request.session["want_to_be_vetted"]
        option3 = request.session["option3"]
        option4 = request.session["option4"]
        option5 = request.session["option5"]
        option6 = request.session["option6"]
        # payment_intent_id = request.session["payment_intent_id"]
        # pi = stripe.PaymentIntent.retrieve(payment_intent_id)
        try:
            s = MNFScriptDatabase.objects.get(user_id=request.user, script_id=script_id)
        except:
            s = MNFScriptDatabase()
            s.user_id = request.user
            s.script_id = script_id
        s.script_title = script_title
        s.author_name = request.user.first_name
        # s.dial_dest_language = dial_dest_language
        # s.dial_dest_script = dial_dest_script
        # s.nondial_dest_language = nondial_dest_language
        # s.dual_dial_script = dual_dial_script
        s.script_file_path = script_file_path
        # save central payment details in your database
        # s.payment_order_id = "monthly_user"
        # s.central_payment_id = context["central_pay_id"]
        # s.payment_intent_id = payment_intent_id
        s.nondial_src_script = non_dial_src_script
        s.dial_src_script = dial_src_script
        s.dial_src_language = dial_src_lang
        s.nondial_src_language = non_dial_src_lang
        # s.nondial_dest_script = nondial_dest_script
        s.save()

        translation_instance = ScriptTranslations()
        translation_instance.user_id = request.user
        translation_instance.script_link_id = s
        translation_instance.nondial_dest_language = nondial_dest_language
        translation_instance.nondial_dest_script = nondial_dest_script
        translation_instance.dial_dest_language = language_2_code[str(dial_dest_language)]
        translation_instance.dial_dest_script = dial_dest_script
        translation_instance.dual_dial_script = dual_dial_script
        translation_instance.payment_order_id = "monthly_user"
        translation_instance.central_payment_id = request.session["central_pay_id"]
        translation_instance.save()
        request.session['translation_id'] = str(translation_instance.translation_id)

        context = {
            "script_id": script_id,
            "script_title": script_title,
            "script_file_path": script_file_path,
            "dial_conv_script": dial_conv_script,
            "nondial_dest_language": nondial_dest_language,
            "dial_dest_language": dial_dest_language,
            "dial_dest_script": dial_dest_script,
            "dial_src_lang": dial_src_lang,
            "non_dial_src_lang": non_dial_src_lang,
            "dial_src_script": dial_src_script,
            "dual_dial_script": dual_dial_script,
            "total_amount": total_amount,
            "to_be_vetted_by_lpp": to_be_vetted_by_lpp,
            "restrict_to_five": "no",
            "option3": option3,
            "option4": option4,
            "option5": option5,
            "option6": option6,
        }
        # return redirect('conversion')
        # return JsonResponse(context)
        return render(request, "conversion/thanksconversion.html", context)


def paymentDoneC_Institutional(request):
    if request.method == "GET":

        script_id = request.session["script_id"]
        script_title = request.session["script_title"]
        script_file_path = request.session["script_file_path"]
        dial_conv_script = request.session["dial_conv_script"]
        nondial_dest_language = request.session["nondial_dest_language"]
        dial_dest_language = request.session["dial_dest_language"]
        dial_dest_script = request.session["dial_dest_script"]
        dial_src_lang = request.session["dial_src_lang"]
        non_dial_src_lang = request.session["non_dial_src_lang"]
        dial_src_script = request.session["dial_src_script"]
        non_dial_src_script = request.session["non_dial_src_script"]
        dual_dial_script = request.session["dual_dial_script"]
        nondial_dest_script = request.session["nondial_dest_script"]
        if request.session.get("want_to_be_vetted") != "NO":
            total_amount = request.session["lppamount"]
        else:
            total_amount = request.session["amount"]
        to_be_vetted_by_lpp = request.session["want_to_be_vetted"]
        option3 = request.session["option3"]
        option4 = request.session["option4"]
        option5 = request.session["option5"]
        option6 = request.session["option6"]
        # payment_intent_id = request.session["payment_intent_id"]
        # pi = stripe.PaymentIntent.retrieve(payment_intent_id)
        try:
            s = MNFScriptDatabase.objects.get(user_id=request.user, script_id=script_id)
        except:
            s = MNFScriptDatabase()
            s.user_id = request.user
            s.script_id = script_id
        s.script_title = script_title
        s.author_name = request.user.first_name
        # s.dial_dest_language = dial_dest_language
        # s.dial_dest_script = dial_dest_script
        # s.nondial_dest_language = nondial_dest_language
        # s.dual_dial_script = dual_dial_script
        s.script_file_path = script_file_path
        # save central payment details in your database
        # s.payment_order_id = "monthly_user"
        # s.central_payment_id = context["central_pay_id"]
        # s.payment_intent_id = payment_intent_id
        s.nondial_src_script = non_dial_src_script
        s.dial_src_script = dial_src_script
        s.dial_src_language = dial_src_lang
        s.nondial_src_language = non_dial_src_lang
        # s.nondial_dest_script = nondial_dest_script
        s.save()

        translation_instance = ScriptTranslations()
        translation_instance.user_id = request.user
        translation_instance.script_link_id = s
        translation_instance.nondial_dest_language = nondial_dest_language
        translation_instance.nondial_dest_script = nondial_dest_script
        translation_instance.dial_dest_language = language_2_code[str(dial_dest_language)]
        translation_instance.dial_dest_script = dial_dest_script
        translation_instance.dual_dial_script = dual_dial_script
        translation_instance.payment_order_id = "Institutional User"
        # translation_instance.central_payment_id = request.session["central_pay_id"]
        translation_instance.save()
        request.session['translation_id'] = str(translation_instance.translation_id)

        context = {
            "script_id": script_id,
            "script_title": script_title,
            "script_file_path": script_file_path,
            "dial_conv_script": dial_conv_script,
            "nondial_dest_language": nondial_dest_language,
            "dial_dest_language": dial_dest_language,
            "dial_dest_script": dial_dest_script,
            "dial_src_lang": dial_src_lang,
            "non_dial_src_lang": non_dial_src_lang,
            "dial_src_script": dial_src_script,
            "dual_dial_script": dual_dial_script,
            "total_amount": total_amount,
            "to_be_vetted_by_lpp": to_be_vetted_by_lpp,
            "restrict_to_five": "no",
            "option3": option3,
            "option4": option4,
            "option5": option5,
            "option6": option6,
        }
        # return redirect('conversion')
        # return JsonResponse(context)
        return render(request, "conversion/thanksconversion.html", context)



# -> Conversion Stripe Payment Done Message
def paymentDoneC(request):

    if request.method == "GET":

        script_id = request.session["script_id"]
        script_title = request.session["script_title"]
        script_file_path = request.session["script_file_path"]
        dial_conv_script = request.session["dial_conv_script"]
        nondial_dest_language = request.session["nondial_dest_language"]
        dial_dest_language = request.session["dial_dest_language"]
        dial_dest_script = request.session["dial_dest_script"]
        dial_src_lang = request.session["dial_src_lang"]
        non_dial_src_lang = request.session["non_dial_src_lang"]
        dial_src_script = request.session["dial_src_script"]
        non_dial_src_script = request.session["non_dial_src_script"]
        dual_dial_script = request.session["dual_dial_script"]
        nondial_dest_script = request.session["nondial_dest_script"]
        if request.session.get("want_to_be_vetted"):
            total_amount = request.session["amount"]
        else:
            total_amount = request.session["amount"]
        to_be_vetted_by_lpp = request.session["want_to_be_vetted"]
        option3 = request.session["option3"]
        option4 = request.session["option4"]
        option5 = request.session["option5"]
        option6 = request.session["option6"]
        # payment_intent_id = request.session["payment_intent_id"]
        # pi = stripe.PaymentIntent.retrieve(payment_intent_id)
        print("all get 8989 variables", request.GET.items())
        for key, value in request.GET.items():
            print(rf'{key}: {value}')
        response = {
            "id": request.GET.get("payment_intent"),
            "client_secret": request.GET.get("payment_intent_client_secret"),
            "status": request.GET.get("redirect_status"),
        }
        callback_content = callback(response, request)
        if callback_content['payment_status'] == "success":
            if request.session["pay_with_wallet"] == "yes":
                # deduction_for_sep_wall(request)
                wall = Wallet.objects.get(user=request.user)
                # for key, value in request.session.items():
                #     print('{} => {}'.format(key, value))
                print("----------------amount", request.session["pay_wallet_deduction"])
                print("----------------rate", request.session["CurrencyRate"])
                print("final balance", round(wall.balance, 2) - (
                    round(request.session["pay_wallet_deduction"], 2)))
                wall.balance = round(wall.balance, 2) - (
                    round(request.session["pay_wallet_deduction"], 2))
                wall.save()

            # c = conversionPayment()
            try:
                s = MNFScriptDatabase.objects.get(user_id=request.user, script_id=script_id)
            except:
                s = MNFScriptDatabase()
                s.user_id = request.user
                s.script_id = script_id
            s.user_id = request.user
            s.script_id = script_id
            s.script_title = script_title
            s.author_name = request.user.first_name
            # s.dial_dest_language = dial_dest_language
            # s.dial_dest_script = dial_dest_script
            # s.nondial_dest_language = nondial_dest_language
            # s.dual_dial_script = dual_dial_script
            s.script_file_path = script_file_path
            # save central payment details in your database
            # s.payment_order_id = request.session["payment_order_id"]
            # s.central_payment_id = request.session["central_payment_id"]
            # s.payment_intent_id = payment_intent_id
            s.nondial_src_script = non_dial_src_script
            s.dial_src_script = dial_src_script
            s.dial_src_language = dial_src_lang
            s.nondial_src_language = non_dial_src_lang
            # s.nondial_dest_script = nondial_dest_script
            # try:
            #     if request.session["is_juggernaut_used"]:
            #         s.is_juggernaut_used = True
            #         s.languages_juggernaut = request.session['languages_juggernaut']
            # except:
            #     pass
            # s.save()
            # try:
            #     if request.session["juggernaut_pages_deduction"]:
            #         update_juggernaut(request, user_id=request.user.id, service_name="conversion",
            #                           conversion_pages=int(request.session["juggernaut_pages_deduction"]), associated_project=s, translation_language=str(dial_dest_language))
            # except Exception as e:
            #     print("Error is: ", e)


            translation_instance = ScriptTranslations()
            translation_instance.user_id = request.user
            translation_instance.script_link_id = s
            translation_instance.nondial_dest_language = nondial_dest_language
            translation_instance.nondial_dest_script = nondial_dest_script
            translation_instance.dial_dest_language = language_2_code[str(dial_dest_language)]
            translation_instance.dial_dest_script = dial_dest_script
            translation_instance.dual_dial_script = dual_dial_script
            translation_instance.payment_order_id = request.session["payment_order_id"]
            translation_instance.central_payment_id = request.session["central_payment_id"]
            translation_instance.save()
            print("saving")
            request.session['translation_id'] = str(translation_instance.translation_id)
            # -----------Adding Details to payment Details--------------------------
            # currencyrate = request.session["CurrencyRate"]
            # user_id = request.user
            # payment_id = payment_intent_id
            # services_used = "Conversion"
            # script_info = s
            # number_of_pages = request.session["numPages"]
            # total_amounts = round(
            #     (request.session["numPages"] *
            #      CONVERSION_PER_PAGE * currencyrate),
            #     2,
            # )
            # discount = round((request.session["discount"] * currencyrate), 2)
            # amount_charged = round((total_amount * currencyrate), 2)
            # gateway_fee = round(
            #     ((STRIPE_PLATFORM_FEE / 100) * amount_charged), 2)
            # currency = "INR"
            # pay_method = "Card"
            # payment_status = "Success"
            # payment_gateway = "Stripe"
            # PaymentData.objects.create(
            #     user_id=user_id,
            #     services_used=services_used,
            #     payment_id=payment_id,
            #     script_info=script_info,
            #     amount_charged=amount_charged,
            #     total_amount=total_amounts,
            #     number_of_pages=number_of_pages,
            #     gateway_fee=gateway_fee,
            #     discount=discount,
            #     currency=currency,
            #     pay_method=pay_method,
            #     payment_status=payment_status,
            #     payment_gateway=payment_gateway,
            # )

            # c.pid = privilegedUser1.objects.get(user= request.user)
            # c.script_title = script_title
            # c.script_id = script_id
            # c.to_be_vetted_by_lpp = to_be_vetted_by_lpp
            # c.payment_intent_id = payment_intent_id
            # c.total_amount = str(total_amount)
            # c.script_file_path = script_file_path
            # c.has_paid = 'yes'
            # c.save()
            context = {
                "script_id": script_id,
                "script_title": script_title,
                "script_file_path": script_file_path,
                "dial_conv_script": dial_conv_script,
                "nondial_dest_language": nondial_dest_language,
                "dial_dest_language": dial_dest_language,
                "dial_dest_script": dial_dest_script,
                "dial_src_lang": dial_src_lang,
                "non_dial_src_lang": non_dial_src_lang,
                "dial_src_script": dial_src_script,
                "dual_dial_script": dual_dial_script,
                "total_amount": total_amount,
                "to_be_vetted_by_lpp": to_be_vetted_by_lpp,
                "restrict_to_five": "no",
                "option3": option3,
                "option4": option4,
                "option5": option5,
                "option6": option6,
            }
            to = request.user.email
            key_value = {
                "User": request.user.username,
            }
            sendmail(to_email=[to], email_code="PP19", key_value=key_value)
            return render(request, "conversion/thanksconversion.html", context)
        else:
            # subject = "Something really went wrong"
            # from_email = settings.EMAIL_HOST_USER
            # to = request.user.email
            # context_2 = {
            #     "Name": request.user.email,
            #     "service_name": "Conversion",
            # }
            # mnfnsendemail(
            #     to, subject, "payment/templates/payments/MR24.html", context_2, from_email)

            to = request.user.email
            key_value = {
                "User": request.user.username,
            }
            sendmail(to_email=[to], email_code="PP21", key_value=key_value)
            return render(request, "payments/failed.html")

# -> Conversion Razorpay Payment Done Message


def paymentDoneC_RazorPay(request):
    print("po")
    print("PAyment Done Razorpay -> ", request.POST)
    # print("PAyment Done Razorpay -> ", request.POST.data, "444")
    keyID = request.session["keyID"]
    keySecret = request.session["keySecret"]
    if request.method == "POST":
        script_id = request.session["script_id"]
        script_title = request.session["script_title"]
        script_file_path = request.session["script_file_path"]
        dial_conv_script = request.session["dial_conv_script"]
        nondial_dest_language = request.session["nondial_dest_language"]
        dial_dest_language = request.session["dial_dest_language"]
        dial_dest_script = request.session["dial_dest_script"]
        dial_src_lang = request.session["dial_src_lang"]
        non_dial_src_lang = request.session["non_dial_src_lang"]
        dial_src_script = request.session["dial_src_script"]
        dual_dial_script = request.session["dual_dial_script"]
        non_dial_src_script = request.session["non_dial_src_script"]
        nondial_dest_script = request.session["nondial_dest_script"]
        if request.session.get("want_to_be_vetted"):
            total_amount = request.session["amount"]
        else:
            total_amount = request.session["amount"]
        to_be_vetted_by_lpp = request.session["want_to_be_vetted"]
        option3 = request.session["option3"]
        option4 = request.session["option4"]
        option5 = request.session["option5"]
        option6 = request.session["option6"]
        # razorpay_order_id = request.POST["razorpay_order_id"]
        # razorpay_payment_id = request.POST["razorpay_payment_id"]
        # razorpay_signature = request.POST["razorpay_signature"]
        # client = razorpay.Client(auth=(keyID, keySecret))
        # params_dict = {
        #     "razorpay_order_id": razorpay_order_id,
        #     "razorpay_payment_id": razorpay_payment_id,
        #     "razorpay_signature": razorpay_signature,
        # }
        # try:
        #     client.utility.verify_payment_signature(params_dict)

        callback_context = callback(request.POST, request)

        if callback_context['payment_status'] != 'success':
            subject = "Something really went wrong"
            from_email = settings.EMAIL_HOST_USER
            to = request.user.email
            context_2 = {
                "Name": request.user.email,
                "service_name": "Conversion",
            }
            mnfnsendemail(
                to, subject, "payment/templates/payments/MR24.html", context_2, from_email)
            return render(request, "payments/failed.html")

        if request.session["pay_with_wallet"] == "yes":
            # deduction_for_sep_wall(request)
            wall = Wallet.objects.get(user=request.user)
            # for key, value in request.session.items():
            #     print('{} => {}'.format(key, value))
            print("----------------amount", request.session["pay_wallet_deduction"])
            print("----------------rate", request.session["CurrencyRate"])
            print("final balance", round(wall.balance, 2) - (round(request.session["pay_wallet_deduction"], 2)))
            wall.balance = round(wall.balance, 2) - (round(request.session["pay_wallet_deduction"], 2))
            wall.save()

        # c = conversionPayment()
        try:
            s = MNFScriptDatabase.objects.get(user_id=request.user, script_id=script_id)
            print("KArdunga 1")
        except:
            print("KArdunga 2")
            s = MNFScriptDatabase()
            s.user_id = request.user
            s.script_id = script_id
        s.user_id = request.user
        s.script_id = script_id
        s.script_title = script_title
        s.author_name = request.user.first_name
        # s.dial_dest_language = dial_dest_language
        # s.dial_dest_script = dial_dest_script
        # s.nondial_dest_language = nondial_dest_language
        # s.dual_dial_script = dual_dial_script
        s.script_file_path = script_file_path
        # s.payment_intent_id = razorpay_payment_id
        s.nondial_src_script = non_dial_src_script
        s.dial_src_script = dial_src_script
        s.dial_src_language = dial_src_lang
        s.nondial_src_language = non_dial_src_lang
        # s.nondial_dest_script = nondial_dest_script
        s.numPages = request.session["numPages"]
        # save central payment details in your database
        # s.payment_order_id = request.session["payment_order_id"]
        # # save central payment details in your database
        # s.central_payment_id = request.session["central_payment_id"]
        # try:
        #     if request.session["is_juggernaut_used"]:
        #         s.is_juggernaut_used = True
        #         s.languages_juggernaut = request.session['languages_juggernaut']
        # except:
        #     pass
        s.save()
        translation_instance = ScriptTranslations()
        translation_instance.user_id = request.user
        translation_instance.script_link_id = s
        translation_instance.nondial_dest_language = nondial_dest_language
        translation_instance.nondial_dest_script = nondial_dest_script
        translation_instance.dial_dest_language = language_2_code[str(dial_dest_language)]
        translation_instance.dial_dest_script = dial_dest_script
        translation_instance.dual_dial_script = dual_dial_script
        # save central payment details in your database
        translation_instance.payment_order_id = request.session["payment_order_id"]
        translation_instance.central_payment_id = request.session["central_payment_id"]
        translation_instance.save()
        print("saving")
        request.session['translation_id'] = str(translation_instance.translation_id)
        # c.pid = privilegedUser1.objects.get(user= request.user)
        # c.script_title = script_title
        # c.script_id = script_id
        # c.to_be_vetted_by_lpp = to_be_vetted_by_lpp
        # c.payment_intent_id = razorpay_payment_id
        # c.total_amount = str(total_amount)
        # c.script_file_path = script_file_path
        # c.has_paid = 'yes'
        # c.save()
        # request.session["payment_order_id"] = context["orderId"]
        # request.session["central_payment_id"]
        # payFetch = client.payment.fetch(razorpay_payment_id,({'expand[]':'card'}))
        # if client.payment.fetch(razorpay_payment_id, {"expand[]": "card"}):
        #     pay_method = "CARD"
        # else:
        #     pay_method = "NOTCard"
        # # -----------Adding Details to payment Details--------------------------
        # currencyrate = request.session["CurrencyRate"]
        # user_id = request.user
        # payment_id = razorpay_payment_id
        # services_used = "Conversion"
        # script_info = s
        # total_amounts = round(
        #     (request.session["numPages"] * CONVERSION_PER_PAGE * currencyrate),
        #     2,
        # )
        # discount = round((request.session["discount"] * currencyrate), 2)
        # amount_charged = round((total_amount * currencyrate), 2)
        # gateway_fee = round(
        #     ((RAZORPAY_PLATFORM_FEE / 100) * amount_charged), 2)
        # currency = "INR"
        # # pay_method = 'NOTCard'
        # payment_status = "Success"
        # payment_gateway = "RazorPay"
        # number_of_pages = request.session["numPages"]
        # print("totalamount:", total_amounts)
        # print("amountcharge:", amount_charged)
        # print("discount:", discount)
        # PaymentData.objects.create(
        #     user_id=user_id,
        #     payment_id=payment_id,
        #     total_amount=total_amounts,
        #     services_used=services_used,
        #     script_info=script_info,
        #     discount=discount,
        #     amount_charged=amount_charged,
        #     gateway_fee=gateway_fee,
        #     currency=currency,
        #     number_of_pages=number_of_pages,
        #     pay_method=pay_method,
        #     payment_status=payment_status,
        #     payment_gateway=payment_gateway,
        # )
        # try:
        #     if request.session["directly_pay_monthly"]:
        #         lasto = privilegedUser1.objects.last()
        #         privilegedUser1.objects.create(
        #             id=int(lasto.id) + 1,
        #             user=user_id,
        #             is_active="yes",
        #             transactionId=payment_id,
        #             memberType="normal",
        #             months=1
        #         )
        #         del request.session['directly_pay_monthly']
        # except:
        #     pass
        # try:
        #     if request.session["juggernaut_pages_deduction"]:
        #         update_juggernaut(request, user_id=request.user.id, service_name="conversion",
        #                           conversion_pages=int(request.session["juggernaut_pages_deduction"]),
        #                           associated_project=s, translation_language=str(dial_dest_language))
        # except Exception as e:
        #     print("Error is: ", e)
        context = {
            "script_id": script_id,
            "script_title": script_title,
            "script_file_path": script_file_path,
            "dial_conv_script": dial_conv_script,
            "nondial_dest_language": nondial_dest_language,
            "dial_dest_language": dial_dest_language,
            "dial_dest_script": dial_dest_script,
            "dial_src_lang": dial_src_lang,
            "non_dial_src_lang": non_dial_src_lang,
            "dial_src_script": dial_src_script,
            "dual_dial_script": dual_dial_script,
            "total_amount": total_amount,
            "to_be_vetted_by_lpp": to_be_vetted_by_lpp,
            "restrict_to_five": "no",
            "option3": option3,
            "option4": option4,
            "option5": option5,
            "option6": option6,
        }
        to = request.user.email
        key_value = {
            "User": request.user.username,
        }
        sendmail(to_email=[to], email_code="PP19", key_value=key_value)

        return render(request, "conversion/thanksconversion.html", context)
    else:
        #     print("Get Request after payment is done razorpay1515")
        #     subject = "Something really went wrong"
        #     from_email = settings.EMAIL_HOST_USER
        #     to = request.user.email
        #     context_2 = {
        #         "Name": request.user.email,
        #         "service_name": "Conversion",
        #     }
        #     mnfnsendemail(
        #         to, subject, "payment/templates/payments/MR24.html", context_2, from_email)
        #     return render(request, "payments/failed.html")
        to = request.user.email
        key_value = {
            "User": request.user.username,
        }
        sendmail(to_email=[to], email_code="PP21", key_value=key_value)
        return render(request, "payments/failed.html")

# -> Conversion Razorpay Payment Done Message


def paymentDoneppt_RazorPay(request):
    keyID = request.session["keyID"]
    keySecret = request.session["keySecret"]
    if request.method == "POST":
        # x = pptconversion.objects.get(ppt_string=request.session["pptstring"])
        # if request.session.get("want_to_be_vetted") == "on":
        #     total_amount = x.amount
        # else:
        #     total_amount = x.amount
        # razorpay_order_id = request.POST["razorpay_order_id"]
        # razorpay_payment_id = request.POST["razorpay_payment_id"]
        # razorpay_signature = request.POST["razorpay_signature"]
        # client = razorpay.Client(auth=(keyID, keySecret))
        # params_dict = {
        #     "razorpay_order_id": razorpay_order_id,
        #     "razorpay_payment_id": razorpay_payment_id,
        #     "razorpay_signature": razorpay_signature,
        # }
        # try:
        #     client.utility.verify_payment_signature(params_dict)
        # except:
        #     x.delete()
        #     subject = "Something really went wrong"
        #     from_email = settings.EMAIL_HOST_USER
        #     to = request.user.email
        #     context_2 = {
        #         "Name": request.user.email,
        #         "service_name": "Conversion",
        #     }
        #     mnfnsendemail(
        #         to, subject, "payment/templates/payments/MR24.html", context_2, from_email)
        #     return render(request, "payments/failed.html")
        #
        # if request.session["pay_with_wallet"] == "yes":
        #     deduction_for_sep_wall(request)
        #     wall = Wallet.objects.get(user=request.user)
        #     wall.balance = request.session["fbalance"]
        #     wall.save()
        #
        # # payFetch = client.payment.fetch(razorpay_payment_id,({'expand[]':'card'}))
        # if client.payment.fetch(razorpay_payment_id, {"expand[]": "card"}):
        #     pay_method = "CARD"
        # else:
        #     pay_method = "NOTCard"
        # # -----------Adding Details to payment Details--------------------------
        # currencyrate = request.session["CurrencyRate"]
        # user_id = request.user
        # payment_id = razorpay_payment_id
        # services_used = "Conversion"
        # total_amounts = round(
        #     (x.slide_count * CONVERSION_PER_PAGE * currencyrate),
        #     2,
        # )
        # discount = round((request.session["pptdiscount"] * currencyrate), 2)
        # amount_charged = round((total_amount * currencyrate), 2)
        # gateway_fee = round(
        #     ((RAZORPAY_PLATFORM_FEE / 100) * amount_charged), 2)
        # currency = "INR"
        # # pay_method = 'NOTCard'
        # payment_status = "Success"
        # payment_gateway = "RazorPay"
        # number_of_pages = x.slide_count
        # print("totalamount:", total_amounts)
        # print("amountcharge:", amount_charged)
        # print("discount:", discount)
        # PaymentData.objects.create(
        #     user_id=user_id,
        #     payment_id=payment_id,
        #     total_amount=total_amounts,
        #     services_used=services_used,
        #     discount=discount,
        #     amount_charged=amount_charged,
        #     gateway_fee=gateway_fee,
        #     currency=currency,
        #     number_of_pages=number_of_pages,
        #     pay_method=pay_method,
        #     payment_status=payment_status,
        #     payment_gateway=payment_gateway,
        # )
        #
        # with open(rf"{basePath}/ideamall/templates/ideamall/body.txt") as f:
        #     body = f.read()
        #
        # context_email = {
        #     "Date": date.today(),
        #     "Name": x.user_id.email,
        #     "emailcode": "",
        #     "heading1": "Thank you!",
        #     "heading2": " for using ppt conversion service "
        #     + " you will get notification whenever the conversation completes",
        #     "body": body,
        # }
        # # whomtosend, titleofmail, dateofemail, context\
        # sendemail(
        #     x.user_id.email,
        #     "Thankyou for using service",
        #     date.today(),
        #     context_email,
        #     EMAIL_HOST_USER,
        # ).start()
        # # sdsdsadsadsdsadsadsdsdasdsaaaaaaassss
        callback_context = callback(request.POST, request)
        ppt_id = request.session["ppt_id"]
        if callback_context['payment_status'] != 'success':

            pptconversion.objects.get(ppt_id=ppt_id).delete()
            subject = "Something really went wrong"
            from_email = settings.EMAIL_HOST_USER
            to = request.user.email
            context_2 = {
                "Name": request.user.email,
                "service_name": "Conversion",
            }
            mnfnsendemail(
                to, subject, "payment/templates/payments/MR24.html", context_2, from_email)
            # sendmail(to_email=[ppt_instance.user_id.email,email_code='CP5')
            return render(request, "payments/failed.html")
        else:
            total_amount = request.session["amount"]
            if request.session["pay_with_wallet"] == "yes":
                # deduction_for_sep_wall(request)
                wall = Wallet.objects.get(user=request.user)
                # for key, value in request.session.items():
                #     print('{} => {}'.format(key, value))
                print("----------------amount", request.session["pay_wallet_deduction"])
                print("----------------rate", request.session["CurrencyRate"])
                print("final balance", round(wall.balance, 2) - (round(request.session["pay_wallet_deduction"], 2)))
                wall.balance = round(wall.balance, 2) - (round(request.session["pay_wallet_deduction"], 2))
                wall.save()
            ppt_instance = pptconversion.objects.get(ppt_id=ppt_id)
            # save central payment details in your database
            ppt_instance.central_payment_id = request.session["central_payment_id"]
            ppt_instance.payment_order_id = request.session["payment_order_id"]
            ppt_instance.save()
            sendmail(to_email=[ppt_instance.user_id.email], email_code='CP4')
            sendmail(to_email=[ppt_instance.user_id.email], email_code='CP10')
            ppt_conversion(ppt_id, request).start()
            sendmail(to_email=[ppt_instance.user_id.email], email_code='CP9')
            print('line---(2161)')
            print('is the email working for ppt')
            print('ppt_instance.user_id.email', ppt_instance.user_id.email)
            del request.session["pptstring"]
            return render(request, "conversion/thanksppt.html")


# -> Conversion Stripe Payment Done Message
def paymentDoneppt_stripe(request):

    if request.method == "GET":
        ppt_id = request.session["ppt_id"]
    #     x = pptconversion.objects.filter(
    #         ppt_string=request.session["pptstring"])
    #
    #     total_amount = x.amount
    #     payment_intent_id = request.session["payment_intent_id"]
    #     try:
    #         pi = stripe.PaymentIntent.retrieve(payment_intent_id)
    #     except:
    #         x.delete()
    #         subject = "Something really went wrong"
    #         from_email = settings.EMAIL_HOST_USER
    #         to = request.user.email
    #         context_2 = {
    #             "Name": request.user.email,
    #             "service_name": "Conversion",
    #         }
    #         mnfnsendemail(
    #             to, subject, "payment/templates/payments/MR24.html", context_2, from_email)
    #         return render(request, "payments/failed.html")
    #
    #     if pi.status == "succeeded":
    #
    #         if request.session["pay_with_wallet"] == "yes":
    #             deduction_for_sep_wall(request)
    #             wall = Wallet.objects.get(user=request.user)
    #             wall.balance = request.session["fbalance"]
    #             wall.save()
    #
    #         # -----------Adding Details to payment Details--------------------------
    #         currencyrate = request.session["CurrencyRate"]
    #         user_id = request.user
    #         payment_id = payment_intent_id
    #         services_used = "Conversion"
    #         number_of_pages = x.slide_count
    #         total_amounts = round(
    #             (x.slide_count * CONVERSION_PER_PAGE * currencyrate),
    #             2,
    #         )
    #         discount = round(
    #             (request.session["pptdiscount"] * currencyrate), 2)
    #         amount_charged = round((total_amount * currencyrate), 2)
    #         gateway_fee = round(
    #             ((STRIPE_PLATFORM_FEE / 100) * amount_charged), 2)
    #         currency = "INR"
    #         pay_method = "Card"
    #         payment_status = "Success"
    #         payment_gateway = "Stripe"
    #         PaymentData.objects.create(
    #             user_id=user_id,
    #             services_used=services_used,
    #             payment_id=payment_id,
    #             amount_charged=amount_charged,
    #             total_amount=total_amounts,
    #             number_of_pages=number_of_pages,
    #             gateway_fee=gateway_fee,
    #             discount=discount,
    #             currency=currency,
    #             pay_method=pay_method,
    #             payment_status=payment_status,
    #             payment_gateway=payment_gateway,
    #         )
    #
    #     with open(rf"{basePath}/ideamall/templates/ideamall/body.txt") as f:
    #         body = f.read()
    #
    #     context_email = {
    #         "Date": date.today(),
    #         "Name": x.user_id.email,
    #         "emailcode": "",
    #         "heading1": "Thank you!",
    #         "heading2": " for using ppt conversion service "
    #         + " you will get notification whenever the conversation completes",
    #         "body": body,
    #     }
    #     # whomtosend, titleofmail, dateofemail, context\
    #     sendemail(
    #         x.user_id.email,
    #         "Thankyou for using service",
    #         date.today(),
    #         context_email,
    #         EMAIL_HOST_USER,
    #     ).start()
    #     # sdsdsadsadsdsadsadsdsdasdsaaaaaaassss
    #     ppt_conversion(x.ppt_id, request).start()
    #     return render(request, "conversion/thanksppt.html")
    # else:
    #     x.delete()
    #     subject = "Something really went wrong"
    #     from_email = settings.EMAIL_HOST_USER
    #     to = request.user.email
    #     context_2 = {
    #         "Name": request.user.email,
    #         "service_name": "Conversion",
    #     }
    #     mnfnsendemail(
    #         to, subject, "payment/templates/payments/MR24.html", context_2, from_email)
    #     return render(request, "payments/failed.html")

        response = {
            "id": request.GET.get("payment_intent"),
            "client_secret": request.GET.get("payment_intent_client_secret"),
            "status": request.GET.get("redirect_status"),
        }
        callback_content = callback(response, request)
        if callback_content['payment_status'] == "success":
            if request.session["pay_with_wallet"] == "yes":
                # deduction_for_sep_wall(request)
                wall = Wallet.objects.get(user=request.user)
                # for key, value in request.session.items():
                #     print('{} => {}'.format(key, value))
                print("----------------amount", request.session["pay_wallet_deduction"])
                print("----------------rate", request.session["CurrencyRate"])
                print("final balance", round(wall.balance, 2) - (
                    round(request.session["pay_wallet_deduction"], 2)))
                wall.balance = round(wall.balance, 2) - (
                    round(request.session["pay_wallet_deduction"], 2))
                wall.save()
            ppt_instance = pptconversion.objects.get(ppt_id=ppt_id)
            ppt_instance.central_payment_id = request.session[
                "central_payment_id"]  # save central payment details in your database
            ppt_instance.payment_order_id = request.session["payment_order_id"]
            ppt_instance.save()
            sendmail(to_email=[ppt_instance.user_id.email], email_code='CP4')
            sendmail(to_email=[ppt_instance.user_id.email], email_code='CP10')
            ppt_conversion(ppt_id, request).start()
            sendmail(to_email=[ppt_instance.user_id.email], email_code='CP9')
            print('line---(2282)')
            print('is the email working for ppt')
            del request.session["pptstring"]
            return render(request, "conversion/thanksppt.html")
        else:
            sendmail(to_email=[ppt_instance.user_id.email], email_code='CP')
            pptconversion.objects.get(ppt_id=ppt_id).delete()
            subject = "Something really went wrong"
            from_email = settings.EMAIL_HOST_USER
            to = request.user.email
            context_2 = {
                "Name": request.user.email,
                "service_name": "Conversion",
            }
            mnfnsendemail(
                to, subject, "payment/templates/payments/MR24.html", context_2, from_email)

            return render(request, "payments/failed.html")


# -> Actually Running Translation  of book
def my_book(request):
    print("Entering My_Book Conversion Function")

    # -> PArsing the file location from database
    y = BookConversion.objects.get(book_id=str(request.GET["book_id"]))

    # -> Creating the directory for storing the extracted contents of docx
    path = str(y.upload_book)
    folder_name = (((path.split("/"))[-1]).split("."))[0]

    if not os.path.exists(f"{basePath}/media/scripts/book/{folder_name}"):
        os.mkdir(f"{basePath}/media/scripts/book/{folder_name}", mode=0o777)

    # -> Creating the convert a book instance
    convertBook_instance = ConvertBook()

    # -> Alerting User that transaltion has started
    to = request.user.email
    key_value = {
        "User": request.user.username,
    }
    sendmail(to_email=[to], email_code="PP22", key_value=key_value)

    # -> Extracting the Docx contents as XML
    data_docx_list = convertBook_instance.extract_docx_contents(
        basePath + "/media/" + str(y.upload_book), f"{basePath}/media/scripts/book/{folder_name}")

    print("I am done till here 7878", data_docx_list)

    # -> Translating the contents and Recreating the docx book using the translated text
    convertBook_instance.recreate_translated_book(
        data_docx_list, f"{basePath}/media/scripts/book/{folder_name}/{str(folder_name)}_translated.docx", y.source_language, y.target_language)

    # orig_path = ""
    # for i in range(len(path)):
    #     if i == len(path) - 1:
    #         orig_path = orig_path + str(path[i])
    #     else:
    #         orig_path = orig_path + str(path[i]) + "/"
    y.translated_book_docx = f"/media/scripts/book/{folder_name}/{str(folder_name)}_translated.docx"
    convert_to_pdf(f"{basePath}/media/scripts/book/{folder_name}/{str(folder_name)}_translated.docx",
                   rf"{basePath}/media/scripts/book/{folder_name}/")
    y.translated_book_pdf = rf"/media/scripts/book/{folder_name}/{str(folder_name)}_translated.pdf"
    translated_book_pdf = rf"/media/scripts/book/{folder_name}/{str(folder_name)}_translated.pdf"
    y.save()

    #  bookconversion = {}
    # if UserCredentialsForBlockchain.objects.filter(user=request.user).exists():
    #     contex =request.session["original_book"]
    #     hash = uploadDataToIPFSNode(contex)
    #     print("my_hash1",hash)
    #     bookconversion["original_bookFile_hash"] = hash

    # if UserCredentialsForBlockchain.objects.filter(user=request.user).exists():
    #     contex =translated_book_pdf
    #     hash = uploadDataToIPFSNode(contex)
    #     print("my_hash2",hash)
    #     bookconversion["translated_bookFile_hash"] = hash

    # if UserCredentialsForBlockchain.objects.filter(user=request.user).exists():
    #     blockchain_obj = UserCredentialsForBlockchain.objects.get(user=request.user)
    #     UserId = blockchain_obj.user_id
    #     Project = script_id
    #     Data = str(bookconversion)
    #     userPrivateKey =blockchain_obj.privateKey
    #     userkey =decryptionOfPrivate(userPrivateKey)
    #     hash =UploadConversionData(userkey.decode('utf-8'),UserId,Project,Data)

    to = request.user.email
    key_value = {
        "User": request.user.username,
    }
    sendmail(to_email=[to], email_code="PP23", key_value=key_value)

    print("Exiting My_Book Conversion Function")
    return JsonResponse({"status": "success"}, status=200)


def book_payment(request):
    # new payment 8000
    set_payment_token(request)
    keyID = request.session["keyID"]
    keySecret = request.session["keySecret"]
    if request.method == "POST":
        if request.POST.get("want_to_be_vetted") == "yes":
        #     print("amount to be paid", request.session["amount"])
        #     total_amount = request.session["amount"]
        #     amount_lpp_without_discount = request.session["onlylppfee"]
        #     print(request.session["amount"], " : Final Amount")
            request.session["want_to_be_vetted"] = "on"
        else:
        # print("amount to be paid", request.session["amount"])
        # total_amount = request.session["amount"]
            request.session["want_to_be_vetted"] = request.POST.get(
                "want_to_be_vetted")
        # print("amount to be paid", request.session["amount"])
        total_amount = request.session["amount"]
        # request.session["want_to_be_vetted"] = request.POST.get(
        #     "want_to_be_vetted")
        # request.session["interested_to_be_lpp"] = request.POST.get(
        #     "interested_to_be_lpp"
        # )
        request.session["amount_before_pay_wallet"] = total_amount
        request.session["pay_with_wallet"] = "no"
        try:
            if request.POST.get("pay_wallet") == "on":
                request.session["pay_with_wallet"] = "yes"
                with open(f"{basePath}/MNF/json_keys/conversionRates.json") as c:
                    curr = json.load(c)
                    print(curr["rates"]["INR"])
                    try:
                        rate = curr["rates"]["INR"]
                    except Exception as e:
                        print("checkout error", e)
                        rate = 80
                # balance = float(request.POST["balance"])
                # payable = float(request.POST["payable"])
                # wall = Wallet.objects.get(user=request.user)
                # request.session["fbalance"] = float(
                #     wall.balance) - float(balance * rate)
                # wall.save()
                # request.session["amount"] = payable
                # total_amount = request.session["amount"]
                print("Checking Wallet")
                wall = Wallet.objects.get(user=request.user)
                print("this is walet", wall.balance)
                print(wall.balance)
                if wall.balance >= (total_amount * rate):
                    print("wallet if hai")
                    request.session["pay_wallet_deduction"] = round(total_amount * rate, 2)
                    total_amount = 0
                else:
                    print("wallet else hai")
                    request.session["pay_wallet_deduction"] = round(wall.balance, 2)
                    total_amount = round((round(total_amount * rate, 2) - round(wall.balance, 2)) / rate, 2)

        except Exception as e:
            print("Error is ",e)
        # total_amount = request.session["amount"]
        total_amount1 = request.session["subtotal"]
        # amount_charged = request.session["amount"]
        # amount_discount = request.session["discount"]
        # total_amount1 = request.session["subtotal"]
        # amount_charged = request.session["amount"]
        amount_discount = request.session["discount"]

        services_used = 2 if request.POST.get("want_to_be_vetted") == "yes" else 1
        context = create_indent(request, 'Conversion', str(request.session["book_id"]), services_used, '',
                                total_amount1, total_amount, amount_discount)
        print("Create indent 9987", context)
        for key, value in request.session.items():
            print('{} => {}'.format(key, value))
        print(str(request.session["book_id"]))
        # instance = MNFScriptDatabase.objects.get(script_id=str(request.session["script_id"]))
        with open(f"{basePath}/MNF/json_keys/conversionRates.json") as c:
            curr = json.load(c)
            try:
                rate = curr["rates"]["INR"]
            except Exception as e:
                rate = 80

        request.session["CurrencyRate"] = rate
        centralPayment_instance = CentralPayment.objects.get(
            id=context["central_pay_id"])

        # handle razor pay gateway →
        if "orderId" in context:
            # instance.payment_order_id = context["orderId"]
            # instance.central_payment_id = context["central_pay_id"]
            # instance.save()  # save central payment details in your database
            request.session["payment_order_id"] = context["orderId"]
            request.session["central_payment_id"] = context["central_pay_id"]

            pid = centralPayment_instance.order_id
            amtINR = round(centralPayment_instance.amount_charged * rate, 2)

            context = {
                "pk": keyID,
                "amtINR": amtINR,
                "pid": pid,
                "amount": round(centralPayment_instance.amount_charged,2),
            }
            return render(request, "conversion/checkoutBook_RazorPay.html", context)

        # handle stripe gateway →
        elif "client_secret" in context:
            # save central payment details in your database
            request.session["payment_order_id"] = context["client_secret"]
            request.session["central_payment_id"] = context["central_pay_id"]

            amtINR = round(centralPayment_instance.amount_charged * rate,2)
            context = {
                "pk": STRIPE_PUB_KEY,
                "total_amount": round(centralPayment_instance.amount_charged, 2),
                "secret_key": context["client_secret"],
                "amtINR": amtINR,
                "STRIPE_PUBLISHABLE_KEY": STRIPE_PUB_KEY,

            }
            return render(request, "conversion/checkoutBook_Stripe.html", context)

        # handle corporate profile →
        elif "monthly_user" in context:
            book_instance = BookConversion.objects.get(
                book_id=request.session["book_id"])
            book_instance.central_payment_id = context["central_pay_id"]
            book_instance.payment_order_id = "monthly_user"
            book_instance.save()
            # instance.payment_order_id = "corporate profile"
            # instance.central_payment_id = "corporate profile"
            # instance.save()

            return render(request, "conversion/thanksbook.html", {"book_id": request.session["book_id"]})


# -> At 10sec intervals check if book conversion completed
def is_book_converted(request):
    book_id = request.GET["book_id"]
    obj = StoryConversion.objects.get(story_id=book_id)
    print("book still converting", obj.translated_book_docx)
    if obj.translated_book_docx:
        return JsonResponse({"status": "success"}, status=200)
    else:
        return JsonResponse({"status": "pending"}, status=202)


# -> Fetching the Source Language and Number of Pages of book
def check_book_lang(request):
    y = BookConversion()
    y.user_id = request.user
    now = datetime.datetime.now()
    rightNow = str(now)
    dash_splited = rightNow.split("-")
    str1 = ""
    for i in dash_splited:
        str1 += str(i)
    dash_splited1 = str1.split(" ")
    str2 = ""
    for i in dash_splited1:
        str2 += str(i)
    dash_splited2 = str2.split(":")
    str3 = ""
    for i in dash_splited2:
        str3 += str(i)
    dash_splited3 = str3.split(".")
    str4 = dash_splited3[0]

    # -> Checking Book Source Language
    y.book_id = "book_" + str(str4)
    y.upload_book = request.FILES['my_book']

    # request.session["original_book"] = request.FILES['my_book']
    y.save()

    try:
        number_pages = countPages(
            str(BASE_DIR) + "/media/" +
            str(y.upload_book), str(y.upload_book)[13:-4] + "pdf"
        )
        docxx = docx.Document(str(BASE_DIR) + "/media/" +
                              str(y.upload_book))
        text = ""
        for paragraph in docxx.paragraphs:
            text += paragraph.text
            if text.strip() == "" or text.strip() == " " or len(text.strip()) < 5:
                pass
            else:
                break
        print("text is",text)
        src_language = language_detector(text)
        BookConversion.objects.get(id=y.id).delete()
        return JsonResponse({"Detected Language": languages[src_language], "number_pages": number_pages})
    except Exception as e:
        print("Exception for language not getting detected is:", e)
        BookConversion.objects.get(id=y.id).delete()
        return JsonResponse({}, status=505)


# -> Initital Saving of Book in database and extracting various languages present in that
def convert_book(request):
    print("Request i", request.method)
    if request.method == "POST":
        print("Yes i am in here")
        y = BookConversion()
        y.user_id = request.user
        now = datetime.datetime.now()
        rightNow = str(now)
        dash_splited = rightNow.split("-")
        str1 = ""
        for i in dash_splited:
            str1 += str(i)
        dash_splited1 = str1.split(" ")
        str2 = ""
        for i in dash_splited1:
            str2 += str(i)
        dash_splited2 = str2.split(":")
        str3 = ""
        for i in dash_splited2:
            str3 += str(i)
        dash_splited3 = str3.split(".")
        str4 = dash_splited3[0]

        y.book_id = "book_" + str(str4)
        if request.POST.get("book_id"):
            print("Inside sample book if case")
            # book_sample = SampleBook.objects.get(book_id=request.POST.get("book_id"))
            # y.upload_book = book_sample.book_path
            # # print(request.POST.get("header_footer_addition"), "<- checkbox value")
            # # y.source_language = src_language
            # y.numPages = book_sample.number_pages
            # y.source_language = ((list(languages.keys()))[list(
            #     languages.values()).index(book_sample.source_lang)])
            # y.target_language = ((list(languages.keys()))[list(
            #     languages.values()).index(request.POST.get("target_lang"))])
            # y.header_footer_present = True if request.POST.get(
            #     "header_footer_addition") else False
            # y.save()
        else:

            Book = AScript(request.POST, request.FILES)
            if Book.is_valid():
                y.upload_book = Book.cleaned_data.get("myfile")
                # print(request.POST.get("header_footer_addition"), "<- checkbox value")
                # y.source_language = src_language
                y.numPages = request.POST.get("number_pages_var")
                y.source_language = ((list(languages.keys()))[list(
                    languages.values()).index(request.POST.get("src_lang"))])
                y.target_language = ((list(languages.keys()))[list(
                    languages.values()).index(request.POST.get("target_lang"))])
                y.header_footer_present = True if request.POST.get(
                    "header_footer_addition") else False
                y.save()

        if int(y.numPages) <= 5 or request.POST.get("book_id"):
            return render(request, "conversion/thanksbook.html", {"book_id": y.book_id})

        else:
            context = {}
            if request.POST.get("sample_free") == "on":
                return render(request, "conversion/thanksbook.html", {"book_id": y.book_id, "restrict_to_five":"yes"})
            numPages = int(y.numPages)

            if request.POST.get("to_be_vetted_by_lpp") == "on":
                lpp_available = "yes"
                total_amount = round(int(float(pricing_data('Book Conversion', 4))) * numPages, 2)

            else:
                lpp_available = "no"
                total_amount = round(int(float(pricing_data('Script Conversion', 2))) * numPages, 2)

            context["subtotal"] = round(total_amount, 2)
            context["early_bird_discount"] = discount_limit_handler(DISCOUNT["early_bird"])
            context["early_bird_calculate"] = round(
                float((total_amount) * context["early_bird_discount"] / 100), 2)

            # staff discount
            if User.objects.get(id=request.user.id).is_staff:  # changes done by manoj
                context["sdiscount"] = discount_limit_handler(DISCOUNT["employ_discount"])
                context["staff_discount_calculate"] = round(float(
                    (total_amount - context["early_bird_calculate"]) * context[
                        "sdiscount"] / 100), 2)
            else:
                context["sdiscount"] = 0
                context["staff_discount_calculate"] = 0

            user = User.objects.get(id=request.user.id)

            try:
                memberType = privilegedUser1.objects.filter(user=user, is_active="yes")
                if memberType:
                    memberType = memberType.first().memberType

                    if memberType == "normal":
                        context["pdiscount"] = 0
                        context["membership_discount_calculate"] = 0

                    elif memberType == "yearly":
                        context["pdiscount"] = discount_limit_handler(DISCOUNT["yearly_member_additional"])
                        context["membership_discount_calculate"] = round(float((
                                                                                       total_amount -
                                                                                       context[
                                                                                           "early_bird_calculate"] -
                                                                                       context[
                                                                                           "staff_discount_calculate"]) *
                                                                               context["pdiscount"] / 100), 2)

                    elif memberType == "Life Member":
                        context["pdiscount"] = discount_limit_handler(DISCOUNT["life_member_additional"])
                        context["membership_discount_calculate"] = round(float((
                                                                                       total_amount -
                                                                                       context[
                                                                                           "early_bird_calculate"] -
                                                                                       context[
                                                                                           "staff_discount_calculate"]) *
                                                                               context["pdiscount"] / 100), 2)
                if not privilegedUser1.objects.filter(user=request.user, is_active="yes").exists():
                    context["monthly_membership"] = 1
                    # context["membershipNarration"] = discount_limit_handler(DISCOUNT["monthly_member"])
                    context["pdiscount"] = 0
                    context["membership_discount_calculate"] = 0
            except:
                context["monthly_membership"] = 1
                context["pdiscount"] = 0
                context["membership_discount_calculate"] = 0

            get_student_discount = get_discount(request.user.id, total_amount)
            if get_student_discount == 0:
                context["student_discount"] = 0
                context["student_discount_calculate"] = 0
            else:
                context["student_discount"] = get_student_discount
                context["student_discount_calculate"] = round(float((total_amount -
                                                                     context["early_bird_calculate"] -
                                                                     context["staff_discount_calculate"] -
                                                                     context["membership_discount_calculate"]) *
                                                                    context["student_discount"] / 100), 2)

            context["Total_discount"] = round(float(
                context["early_bird_calculate"] + context["staff_discount_calculate"] +
                context["membership_discount_calculate"] + context["student_discount_calculate"]), 2)
            context["remaining_amount"] = round(float(total_amount - context["Total_discount"]), 2)
            context["net_service_charge"] = round(
                float(context["remaining_amount"]), 2)
            # GST
            context["gst"] = discount_limit_handler(DISCOUNT["gst"])
            context["gst_calculate"] = round(float(context["remaining_amount"] * context["gst"] / 100), 2)
            context["net_payable"] = round(float(context["remaining_amount"] + context["gst_calculate"]), 2)
            print(context)


            # -> OLD Code

            # context["book_id"] = y.book_id
            # request.session["book_id"] = y.book_id
            # payment calculation for book
            # pdiscount = 1
            # sdiscount = 1
            # mdiscount = 1 - settings.RUNNING_DISCOUNT_CONVERSION / 100
            # # numPages = int(numPages)
            #
            # if not privilegedUser1.objects.filter(
            #         user=request.user, is_active="yes"
            # ).exists():
            #     # messages.success(request, "Become privileged member")
            #     # return redirect("payment")
            #     request.session["directly_pay_monthly"] = 1
            #     context = {"directly_pay_monthly": 1}
            # try:
            #     memberType = privilegedUser1.objects.get(
            #         user=request.user, is_active="yes"
            #     ).memberType
            #     if memberType:
            #         if memberType == "normal":
            #             pdiscount = 1
            #             context["pdiscount"] = 0
            #         elif memberType == "yearly":
            #             pdiscount = 1 - settings.YEARLY_MEMBER_ADDITIONAL / 100
            #             context["pdiscount"] = settings.YEARLY_MEMBER_ADDITIONAL
            #         elif memberType == "Life Member":
            #             pdiscount = 1 - settings.LIFE_MEMBER_ADDITIONAL / 100
            #             context["pdiscount"] = settings.LIFE_MEMBER_ADDITIONAL
            #     if User.objects.get(id=request.user.id).is_staff:
            #         sdiscount = 1 - settings.EMPLOY_DISCOUNT / 100
            # except:
            #     pdiscount = 1
            #     sdiscount = 1
            #     context["pdiscount"] = 0
            # # pdiscount = 1
            # # sdiscount = 1
            # # mdiscount = 1 - settings.RUNNING_DISCOUNT_CONVERSION / 100
            # # memberType = privilegedUser1.objects.get(
            # #     user=request.user, is_active="yes"
            # # ).memberType
            # # if memberType:
            # #     if memberType == "normal":
            # #         pdiscount = 1
            # #         context["pdiscount"] = 0
            # #     elif memberType == "yearly":
            # #         pdiscount = 1 - settings.YEARLY_MEMBER_ADDITIONAL / 100
            # #         context["pdiscount"] = settings.YEARLY_MEMBER_ADDITIONAL
            # #     elif memberType == "Life Member":
            # #         pdiscount = 1 - settings.LIFE_MEMBER_ADDITIONAL / 100
            # #         context["pdiscount"] = settings.LIFE_MEMBER_ADDITIONAL
            # if User.objects.get(id=request.user.id).is_staff:
            #     sdiscount = 1 - settings.EMPLOY_DISCOUNT / 100
            # # if request.POST.get("to_be_vetted_by_lpp") == "on":
            # #     lpp_available = "yes"
            # #     try:
            # #         lppamt = (
            # #                 (numPages * settings.CONVERSION_PER_PAGE)
            # #                 + (numPages * settings.LPP_PER_PAGE)
            # #                 + context["directly_pay_monthly"]
            # #         )
            # #     except:
            # #         lppamt = (numPages * settings.CONVERSION_PER_PAGE) + (
            # #                 numPages * settings.LPP_PER_PAGE
            # #         )
            # #     context["subtotal"] = round(
            # #         numPages * settings.CONVERSION_PER_PAGE, 2
            # #     )
            # #     # amt = numPages * settings.CONVERSION_PER_PAGE
            # #     # context["subtotal"] = round(amt, 2)
            # #
            # #     # lppamt = (numPages * settings.CONVERSION_PER_PAGE) + (
            # #     #     numPages * settings.LPP_PER_PAGE
            # #     # )
            # #     context["onlylppfee"] = round((numPages * settings.LPP_PER_PAGE), 2)
            # #     context["sublpptotal"] = round(lppamt, 2)
            # #     context["amount"] = round(
            # #         mdiscount * lppamt * pdiscount * sdiscount, 2
            # #     )
            # #     context["discount"] = lppamt - context["amount"]
            # #     request.session["amount"] = context["amount"]
            # #     request.session["onlylppfee"] = context["onlylppfee"]
            # #     request.session["lppamount"] = context["amount"]
            # #     request.session["discount"] = context["discount"]
            # #     request.session["member_discount"] = mdiscount
            # #     request.session["running_discount"] = pdiscount
            # #     request.session["team_discount"] = sdiscount
            # #     request.session["want_to_be_vetted"] = "on"
            # # else:

            # lpp_available = "no"
            # try:
            #     amt = (
            #         numPages
            #         * settings.CONVERSION_PER_PAGE
            #         + context["directly_pay_monthly"]
            #     )
            # except:
            #     amt = numPages * settings.CONVERSION_PER_PAGE

            # context["subtotal"] = round(
            #     numPages * settings.CONVERSION_PER_PAGE, 2
            # )
            # context["amount"] = round(
            #     mdiscount * amt * pdiscount * sdiscount, 2
            # )
            # context["discount"] = amt - context["amount"]
            #
            # # try:
            # request.session["amount"] = context["amount"]
            # # except:
            # #     request.session["amount"] = context["amount"]
            # request.session["subtotal"] = context["subtotal"]
            # request.session["discount"] = context["discount"]
            #
            # context["conversion_per_page"] = settings.CONVERSION_PER_PAGE
            # context["lpp_per_page"] = settings.LPP_PER_PAGE
            # context[
            #     "running_discount_conversion"
            # ] = settings.RUNNING_DISCOUNT_CONVERSION
            # context["employ_discount"] = settings.EMPLOY_DISCOUNT
            # context["yearly_member_additional"] = settings.YEARLY_MEMBER_ADDITIONAL
            # context["life_member_additional"] = settings.LIFE_MEMBER_ADDITIONAL
            # # context["restrict_to_five"] = "no"
            # context["lpp_available"] = lpp_available.upper()
            # context["numPages"] = numPages
            # context["book_title"] = str(y.upload_book)
            # request.session["book_id"] = str(y.book_id)
            # context["src_lang"] = request.POST.get("src_lang")
            # context["dest_lang"] = request.POST.get("target_lang")
            # # request.session["script_file_path"] = x.script_file_path

            context["restrict_to_five"] = "no"
            context["lpp_available"] = lpp_available.upper()
            context["numPages"] = numPages
            context["book_title"] = str(y.upload_book)
            context["src_lang"] = request.POST.get("src_lang")
            context["dest_lang"] = request.POST.get("target_lang")
            request.session["amount"] = context["net_payable"]
            request.session["subtotal"] = context["subtotal"]
            request.session["discount"] = context["Total_discount"]
            request.session["book_id"] = str(y.book_id)
            request.session["book_title"] = str(y.upload_book)
            request.session["numPages"] = numPages
            try:
                wall = Wallet.objects.get(user=request.user)
                context["balance"] = round(wall.balance, 2)
            except:
                context["balance"] = -1
            with open(f"{basePath}/MNF/json_keys/conversionRates.json") as c:
                curr = json.load(c)
                try:
                    rate = curr["rates"]["INR"]
                    # c = CurrencyRates()
                    # rate = c.get_rate("USD", str(currency.upper()))
                except Exception as e:
                    print("checkout error", e)
                    rate = 80
            context["rate"] = rate
            str1 = str(datetime.datetime.now()).split("-")
            date_at = f'{str1[2][0:2]} - {str1[1]} - {str1[0]}'
            context['date_at'] = date_at
            try:
                cd = centralDatabase.objects.get(user_id=request.user)
                name = cd.firstName if cd.firstName else user.username
                email_id = cd.email if cd.email else user.email
                phone_number = str(cd.countryCode) + str(cd.contact) if cd.contact else "N/A"
                address = cd.address if cd.address else "N/A"
            except:
                name = user.username
                email_id = user.email
                phone_number = "N/A"
                address = "N/A"

            context["name"] = name
            context["email_id"] = email_id
            context["phone_number"] = phone_number
            context["address"] = address
            # try:
            #     context["firstdiscount"] =
            #     context["seconddiscount"] =
            #     context["thirddiscount"] =
            # except Exception as e:
            #     print(e, "<- Error")

            return render(request, "conversion/invoice_book.html", context)

    return render(request, "conversion/convertBook.html")


# -> For Viewing Your Books
# def view_converted_books(request):
#     number = ReferUser.objects.filter(refferedBy=request.user).count()
#     obj = BookConversion.objects.filter(
#         user_id=request.user).order_by("-date_at")
#
#     book_path = []
#     pq = 0
#     for i in obj:
#         if i.translated_book_docx != "":
#             book_path.append(i.translated_book_docx)
#             pq += 1
#
#     return render(
#         request,
#         "conversion/viewConvertedBooks.html",
#         {"script_path": obj, "pq": pq, "number": number},
#     )


# -> For Deleting your Book
def delete_converted_book(request, id):
    to = request.user.email
    key_value = {
        "User": request.user.username,
        "book_name": (((str(BookConversion.objects.get(id=id).upload_book).split("/"))[-1]).split("."))[0]
    }
    sendmail(to_email=[to], email_code="PP25", key_value=key_value)

    BookConversion.objects.get(id=id).delete()
    # if UserCredentialsForBlockchain.objects.filter(user=request.user).exists():
    #     blockchain_obj = UserCredentialsForBlockchain.objects.get(user=request.user)
    #     userkey =decryptionOfPrivate(blockchain_obj.privateKey)
    #     deleteConversion(userkey.decode('utf-8'),blockchain_obj.user_id,id)
    return HttpResponseRedirect("/conversion/view_conversion")


def paymentDoneBook_RazorPay(request):
    keyID = request.session["keyID"]
    keySecret = request.session["keySecret"]
    if request.method == "POST":
        book_id = request.session["book_id"]
        book_title = request.session["book_title"]
        # if request.session.get("want_to_be_vetted"):
        #     total_amount = request.session["lppamount"]
        # else:
        #     total_amount = request.session["amount"]
        # to_be_vetted_by_lpp = request.session["want_to_be_vetted"]
        # total_amount = request.session["amount"]
        # razorpay_order_id = request.POST["razorpay_order_id"]
        # razorpay_payment_id = request.POST["razorpay_payment_id"]
        # razorpay_signature = request.POST["razorpay_signature"]
        # client = razorpay.Client(auth=(keyID, keySecret))
        # params_dict = {
        #     "razorpay_order_id": razorpay_order_id,
        #     "razorpay_payment_id": razorpay_payment_id,
        #     "razorpay_signature": razorpay_signature,
        # }

        callback_context = callback(request.POST, request)
        if callback_context['payment_status'] != 'success':
            BookConversion.objects.get(book_id=book_id).delete()
            # subject = "Something really went wrong"
            # from_email = settings.EMAIL_HOST_USER
            # to = request.user.email
            # context_2 = {
            #     "Name": request.user.email,
            #     "service_name": "Conversion",
            # }
            # mnfnsendemail(
            #     to, subject, "payment/templates/payments/MR24.html", context_2, from_email)

            # -> PAyment UnSuccessfull Email
            to = request.user.email
            key_value = {
                "User": request.user.username,
            }
            sendmail(to_email=[to], email_code="PP26", key_value=key_value)

            return render(request, "payments/failed.html")
        else:

            # if request.session["pay_with_wallet"] == "yes":
            #     deduction_for_sep_wall(request)
            #     wall = Wallet.objects.get(user=request.user)
            #     wall.balance = request.session["fbalance"]
            #     wall.save()

            if request.session["pay_with_wallet"] == "yes":
                # deduction_for_sep_wall(request)
                wall = Wallet.objects.get(user=request.user)
                # for key, value in request.session.items():
                #     print('{} => {}'.format(key, value))
                print("----------------amount", request.session["pay_wallet_deduction"])
                print("----------------rate", request.session["CurrencyRate"])
                print("final balance", round(wall.balance, 2) - (round(request.session["pay_wallet_deduction"], 2)))
                wall.balance = round(wall.balance, 2) - (round(request.session["pay_wallet_deduction"], 2))
                wall.save()

            book_instance = BookConversion.objects.get(book_id=book_id)
            # save central payment details in your database
            book_instance.central_payment_id = request.session["central_payment_id"]
            book_instance.payment_order_id = request.session["payment_order_id"]
            book_instance.save()

            # -> PAyment UnSuccessfull Email
            to = request.user.email
            key_value = {
                "User": request.user.username,
            }
            sendmail(to_email=[to], email_code="PP24", key_value=key_value)

            return render(request, "conversion/thanksbook.html", {"book_id": book_id})

        # c = conversionPayment()
        # c.pid = privilegedUser1.objects.get(user= request.user)
        # c.script_title = script_title
        # c.script_id = script_id
        # c.to_be_vetted_by_lpp = to_be_vetted_by_lpp
        # c.payment_intent_id = razorpay_payment_id
        # c.total_amount = str(total_amount)
        # c.script_file_path = script_file_path
        # c.has_paid = 'yes'
        # c.save()

        # payFetch = client.payment.fetch(razorpay_payment_id,({'expand[]':'card'}))
        # if client.payment.fetch(razorpay_payment_id, {"expand[]": "card"}):
        #     pay_method = "CARD"
        # else:
        #     pay_method = "NOTCard"
        # # -----------Adding Details to payment Details--------------------------
        # currencyrate = request.session["CurrencyRate"]
        # user_id = request.user
        # payment_id = razorpay_payment_id
        # services_used = "Book Conversion"
        # # script_info = s
        # total_amounts = round(
        #     (request.session["numPages"] * CONVERSION_PER_PAGE * currencyrate),
        #     2,
        # )
        # discount = round((request.session["discount"] * currencyrate), 2)
        # amount_charged = round((total_amount * currencyrate), 2)
        # gateway_fee = round(
        #     ((RAZORPAY_PLATFORM_FEE / 100) * amount_charged), 2)
        # currency = "INR"
        # # pay_method = 'NOTCard'
        # payment_status = "Success"
        # payment_gateway = "RazorPay"
        # number_of_pages = request.session["numPages"]
        # PaymentData.objects.create(
        #     user_id=user_id,
        #     payment_id=payment_id,
        #     total_amount=total_amounts,
        #     services_used=services_used,
        #     # script_info=script_info,
        #     discount=discount,
        #     amount_charged=amount_charged,
        #     gateway_fee=gateway_fee,
        #     currency=currency,
        #     number_of_pages=number_of_pages,
        #     pay_method=pay_method,
        #     payment_status=payment_status,
        #     payment_gateway=payment_gateway,
        # )
        # try:
        #     if request.session["directly_pay_monthly"]:
        #         lasto = privilegedUser1.objects.last()
        #         privilegedUser1.objects.create(
        #             id=int(lasto.id) + 1,
        #             user=user_id,
        #             is_active="yes",
        #             transactionId=payment_id,
        #             memberType="normal",
        #             months=1
        #         )
        #         del request.session['directly_pay_monthly']
        # except:
        #     pass

        # return render(request, "conversion/thanksconversion.html", context)


def paymentDoneBook_Stripe(request):
    # if pi.status == "succeeded":
    #
    #     if request.session["pay_with_wallet"] == "yes":
    #         deduction_for_sep_wall(request)
    #         walls = Wallet.objects.get(user=request.user)
    #         walls.balance = request.session["fbalance"]
    #         walls.save()
    #
    #     # -----------Adding Details to payment Details--------------------------
    #     currencyrate = request.session["CurrencyRate"]
    #     user_id = request.user
    #     payment_id = payment_intent_id
    #     services_used = "Book Conversion"
    #     # script_info = s
    #     number_of_pages = request.session["numPages"]
    #     total_amounts = round(
    #         (request.session["numPages"] *
    #          CONVERSION_PER_PAGE * currencyrate),
    #         2,
    #     )
    #     discount = round((request.session["discount"] * currencyrate), 2)
    #     amount_charged = round((total_amount * currencyrate), 2)
    #     gateway_fee = round(
    #         ((STRIPE_PLATFORM_FEE / 100) * amount_charged), 2)
    #     currency = "INR"
    #     pay_method = "Card"
    #     payment_status = "Success"
    #     payment_gateway = "Stripe"
    #     PaymentData.objects.create(
    #         user_id=user_id,
    #         services_used=services_used,
    #         payment_id=payment_id,
    #         # script_info=script_info,
    #         amount_charged=amount_charged,
    #         total_amount=total_amounts,
    #         number_of_pages=number_of_pages,
    #         gateway_fee=gateway_fee,
    #         discount=discount,
    #         currency=currency,
    #         pay_method=pay_method,
    #         payment_status=payment_status,
    #         payment_gateway=payment_gateway,
    #     )
    #     try:
    #         if request.session["directly_pay_monthly"]:
    #             lasto = privilegedUser1.objects.last()
    #             privilegedUser1.objects.create(
    #                 id=int(lasto.id) + 1,
    #                 user=user_id,
    #                 is_active="yes",
    #                 transactionId=payment_id,
    #                 memberType="normal",
    #                 months=1
    #             )
    #             del request.session['directly_pay_monthly']
    #     except:
    #         pass
    #
    #     return render(request, "conversion/thanksbook.html", {"book_id": book_id})
    #
    #     # return render(request, "conversion/thanksconversion.html", context)
    # else:
    #     subject = "Something really went wrong"
    #     from_email = settings.EMAIL_HOST_USER
    #     to = request.user.email
    #     context_2 = {
    #         "Name": request.user.email,
    #         "service_name": "Conversion",
    #     }
    #     mnfnsendemail(
    #         to, subject, "payment/templates/payments/MR24.html", context_2, from_email)
    #     return render(request, "payments/failed.html")

    if request.method == "GET":

        book_id = request.session["book_id"]
        book_title = request.session["book_title"]
        # if request.session.get("want_to_be_vetted"):
        #     total_amount = request.session["lppamount"]
        # else:
        #     total_amount = request.session["amount"]
        # total_amount = request.session["amount"]
        # to_be_vetted_by_lpp = request.session["want_to_be_vetted"]
        # payment_intent_id = request.session["payment_intent_id"]
        # pi = stripe.PaymentIntent.retrieve(payment_intent_id)

        response = {
            "id": request.GET.get("payment_intent"),
            "client_secret": request.GET.get("payment_intent_client_secret"),
            "status": request.GET.get("redirect_status"),
        }
        callback_content = callback(response, request)
        if callback_content['payment_status'] == "success":
            # if request.session["pay_with_wallet"] == "yes":
            #     deduction_for_sep_wall(request)
            #     walls = Wallet.objects.get(user=request.user)
            #     walls.balance = request.session["fbalance"]
            #     walls.save()

            if request.session["pay_with_wallet"] == "yes":
                # deduction_for_sep_wall(request)
                wall = Wallet.objects.get(user=request.user)
                # for key, value in request.session.items():
                #     print('{} => {}'.format(key, value))
                print("----------------amount", request.session["pay_wallet_deduction"])
                print("----------------rate", request.session["CurrencyRate"])
                print("final balance", round(wall.balance, 2) - (round(request.session["pay_wallet_deduction"], 2)))
                wall.balance = round(wall.balance, 2) - (round(request.session["pay_wallet_deduction"], 2))
                wall.save()

            book_instance = BookConversion.objects.get(book_id=book_id)
            book_instance.central_payment_id = request.session[
                "central_payment_id"]  # save central payment details in your database
            book_instance.payment_order_id = request.session["payment_order_id"]
            book_instance.save()

            # -> PAyment Successfull Email
            to = request.user.email
            key_value = {
                "User": request.user.username,
            }
            sendmail(to_email=[to], email_code="PP24", key_value=key_value)

            return render(request, "conversion/thanksbook.html", {"book_id": book_id})
        else:
            BookConversion.objects.get(book_id=book_id).delete()
            # subject = "Something really went wrong"
            # from_email = settings.EMAIL_HOST_USER
            # to = request.user.email
            # context_2 = {
            #     "Name": request.user.email,
            #     "service_name": "Conversion",
            # }
            # mnfnsendemail(
            #     to, subject, "payment/templates/payments/MR24.html", context_2, from_email)

            # -> PAyment UnSuccessfull Email
            to = request.user.email
            key_value = {
                "User": request.user.username,
            }
            sendmail(to_email=[to], email_code="PP26", key_value=key_value)

            return render(request, "payments/failed.html")


# #IPFS

# def start_ipfs_daemon():
#     try:
#         # Check if the IPFS daemon is already running
#         subprocess.check_output(["ipfs", "id"])
#         print("IPFS daemon is already running.")
#     except subprocess.CalledProcessError:
#         # If the IPFS daemon is not running, start it
#         print("Starting IPFS daemon...")
#         subprocess.Popen(["ipfs", "daemon"])
#         # Wait for the daemon to start (you can adjust the delay as needed)
#         time.sleep(5)
#         print("IPFS daemon is now running.")
# #IPFS END
# start_ipfs_daemon()


# -> For making Translated PPT's
class ppt_conversion(threading.Thread):
    def __init__(self, ppt, request, restrict=False):
        self.ppt = ppt
        self.request = request
        self.restrict = restrict
        threading.Thread.__init__(self)

    def run(self):
        try:
            x = pptconversion.objects.get(ppt_id=self.ppt)
            presentation = Presentation(x.upload_ppt)
            if self.restrict:
                presentation = Presentation(x.upload_ppt)
                xml_slides = presentation.slides._sldIdLst

                slides = list(xml_slides)

                # Then I loop for all except the first (index 0):

                for index in range(3, len(slides)):
                    xml_slides.remove(slides[index])

            t = random.randint(1, 1000)
            times = time.time()
            times = int(times)
            for key, value in languages.items():
                if value == x.target_lang:
                    target = key
                if value == x.source_lang:
                    source = key
            print(">:>:>:>:12 translation start")
            translate_presentation(presentation, source,
                                   target, x.target_script, self.restrict)
            print(">:>:>:>:12 translation end")

            translated_ppt = f"{x.user_id}-{source}-{target}-{t}-{times}.pptx"
            paths = f"{basePath}/media/ppt/converted/{translated_ppt}"
            presentation.save(paths)
            print(f"presentation convert saved {translated_ppt}")
            x.translated_ppt = translated_ppt
            x.save()
            print('x.user_id.email', x.user_id.email)
            sendmail(to_email=[x.user_id.email], email_code='CP2')

            # Blockchain here--->

            if UserCredentialsForBlockchain.objects.filter(user=self.request.user).exists():
                blockchain_obj = UserCredentialsForBlockchain.objects.get(
                    user=self.request.user)
                privatekey = blockchain_obj.privateKey
                user_id = blockchain_obj.user_id
                Project = self.request.session["script_id"]
                private_Key = decryptionOfPrivate(privatekey)
                status, getData = getPPTConversion(
                    private_Key.decode('utf-8'), user_id, Project)
                if status == True:
                    data1 = getData[1]
                    pptconversion1 = eval(data1)
                    with open(f"{basePath}/media/ppt/converted/{translated_ppt}", 'rb') as _file:
                        hash = uploadDataToIPFSNode(_file)
                        pptconversion1["translated_ppt_hash"] = hash
                    pptconversion1["translated_ppt_path"] = paths
                    pptconversion1["translated_ppt"] = translated_ppt
                    original_file_path = pptconversion1.get("ppt_scriptFile_path")
                    user_id = blockchain_obj.user_id
                    project = self.request.session["script_id"]
                    Data = str(pptconversion1)
                    response = UploadPPTConversionData(
                        OWNER_KEY,blockchain_obj.publicKey,user_id, project, Data)
                    print("Response_final :", response)
                    hash = hash_decrypation(hash)
                    certificatepath = certificateGenrate(self.request.user.username,"PPT Conversion",hash)
                    to_email = [self.request.user.email]
                    email_code = 'BL1'
                    key_value = {
                        "service":"PPT Conversion",
                        "hash": hash,
                        "public key":blockchain_obj.publicKey,
                        "private key":private_Key.decode('utf-8'),
                    }
                    print("::::::::::::::",key_value)
                    sendmail(to_email=to_email , email_code=email_code,key_value=key_value, filePath=certificatepath)




            # For Vetting
            # if request.session
            # obj = ppt.objects.get(script_id=script_id)
            if x.lpp is True:
                print("Making Vetting Request for ppt")
                X = LPPTASKDatabase()
                X.user_id = x.user_id
                X.usernote = "Kindly check if the translated ppt file is correct as per the Uploaded PPT!"
                X.translated_ppt = x
                X.generated_from = "conversion"
                X.amoutgiventolpp_dialogue = self.request.session["lppamount_after_discount"]
                # temp_amount = ((request.session['onlylppfee']) * request.session['team_discount']
                #                 * request.session['member_discount'] * request.session['running_discount'])
                # X.amoutgiventolpp_action = round((temp_amount/2), 2)
                # X.amoutgiventolpp_dialogue = round((temp_amount/2), 2)
                X.save()
                task_assigner(int(X.task_id), "conversion_ppt")
                print("Making Vetting task Request for ppt")

            else:
                # temp1 = str(x.upload_ppt)
                # temp = f"{basePath}/media/{temp1}"
                # data = [temp, paths]
                # print(self.request.session["originalppt"])
                # print(data, x.ppt_string, self.request.user.email,
                #       " : Passed to blockchain")
                # files, timestamp = upload_multiFile_to_ipfs(
                #     data, x.ppt_string, "convertPPT", self.request.user.email)
                # x.timestamp = timestamp
                # x.uploaded_ppt_encoded = files[0]
                # x.translated_ppt_encoded = files[1]
                # print(x.timestamp, x.uploaded_ppt_encoded,
                #       x.translated_ppt_encoded, " : Return from Blockchain")
                x.save()

                # "heading2": f"To view from blockchain use following details: Timestamp - {x.timestamp}, Key - {x.script_title}, Service - convertScript",

                with open(rf"{basePath}/ideamall/templates/ideamall/body.txt") as f:
                    body = f.read()

                context_email = {
                    "Date": date.today(),
                    "Name": x.user_id.email,
                    "emailcode": "",
                    "heading1": "Congratulation! your presentation is converted",
                    "heading2": "Thank you for using our service",
                    "body": body,
                }
            #     import os
            #     if os.path.exists(f"{basePath}/media/ppt/converted/{translated_ppt}"):
            #         os.remove(f"{basePath}/media/ppt/converted/{translated_ppt}")
            #     else:
            #         print("The file does not exist")
            #     if os.path.exists(original_file_path):
            #         os.remove(original_file_path)
            #     else:
            #         print("The file does not exist")
            #     # whomtosend, titleofmail, dateofemail, context\
            #     # sendemail(
            #     #     x.user_id.email,
            #     #     "conversion complete",
            #     #     date.today(),
            #     #     context_email,
            #     #     EMAIL_HOST_USER,
            #     # ).start()

            #     # sendmail(to_email=[x.user_id.email],email_code='CP2')
            # return True
        except Exception as e:
            print("Errorr is", e)
            # write refund code
            x = pptconversion.objects.get(ppt_id=self.ppt)
            auto_refund(x.central_payment_id)



class ppt_Files_Download(threading.Thread):
    def __init__(self, ppt_file, Path):
        self.ppt_file = ppt_file
        self.Path = Path
        threading.Thread.__init__(self)

    def run(self):
        download_file_System(self.ppt_file, self.Path)


    class ppt_Original_Download(threading.Thread):
        def __init__(self, ppt_file, Path):
            self.ppt_file = ppt_file
            self.Path = Path
            threading.Thread.__init__(self)

        def run(self):
            download_file_System(self.ppt_file, self.Path)


def get_ppt_script(request):
    if request.method == "POST":
        df = pd.read_csv(rf"{basePath}/lpp/scripts.csv")
        lang1 = request.POST.get("language")
        print(lang1)
        if lang1 == "":
            lang1 = "English"
        print(lang1, " : languages :: types : ", type(lang1))

        list1_d = df.loc[df[lang1] == "D", "Script"].tolist()
        print("Bakery 20.1: ", list1_d)
        return JsonResponse({"data": list1_d})


# -> Initital Saving of PPT in database and extracting various languages present in that
def pptcovert(request):
    print("Entered ConversionFunction")
    # print("MY base path is " ,str(BASE_DIR))
    if request.method == "POST":
        start_time = time.time()
        restrict = request.POST.get('restrict')
        print(request.POST)
        x = pptconversion()
        x.ppt_string = str(time.time()) + "-ppt"
        ppt_string = str(time.time()) + "-ppt"
        script_id = int(time.time())
        # request.session["script_id"] = str(script_id)
        MyURL = ""
        dial_src_script = ""
        non_dial_src_lang = ""
        non_dial_src_script = ""
        script_title = ""
        author_name = ""
        numPages = 0
        context = {}
        print("pptuploadedfn")
        user_id = request.user
        x.upload_ppt = request.FILES.get("script")
        file_path = str(request.FILES.get("script"))
        request.session["originalppt"] = f"{basePath}/media/ppt/original/{file_path}"
        x.user_id = request.user
        request.session["pptstring"] = x.ppt_string
        author_name = str(request.user.username)
        script_title = x.upload_ppt.name.split("/")[-1]
        request.session["slide_title"] = script_title
        print("pptuploadedfn2")
        prs = Presentation(x.upload_ppt)
        numPages = len(prs.slides)
        if restrict and numPages > 3:
            numPages = 3
        x.slide_count = numPages
        print("Value of restrict:", restrict)
        print("Number of pages:", numPages)

        print(len(prs.slides), "pptuploadedfn3")
        x.save()

        MyURL = "/media/scripts/ppt/" + str(script_title)
        i = 1

 # Blockchain
        pptconversion1 = {}
        if UserCredentialsForBlockchain.objects.filter(user=request.user).exists():
            blockchain_obj = UserCredentialsForBlockchain.objects.get(user=request.user)
            private_Key = decryptionOfPrivate(blockchain_obj.privateKey)
            contex = request.FILES.get("script")
            with open(f"{basePath}/media/{x.upload_ppt}", 'rb') as _file:
                hash = uploadDataToIPFSNode(_file)
                pptconversion1["ppt_scriptFile_hash"] = hash
                print("my_hash1", hash)
            current_datetime = datetime.datetime.now()
            pptconversion1["slide_count"] = numPages
            pptconversion1["ppt_string"] = ppt_string
            pptconversion1["script_title"] = script_title
            pptconversion1["non_dial_src_lang"] = non_dial_src_lang
            pptconversion1["author_name"] = author_name
            pptconversion1["ppt_scriptFile_path"] = f"{basePath}/media/{x.upload_ppt}"
            pptconversion1["upload_ppt"] = f"{x.upload_ppt}"

            pptconversion1["date_at"] = current_datetime.strftime(
                "%Y-%m-%d %H:%M:%S")
            hash = hash_decrypation(hash)
            certificatepath = certificateGenrate(request.user.username,"Original PPT",hash)

            to_email = [request.user.email]
            email_code = 'BL1'
            key_value = {
                "service":"Original PPT",
                "hash": hash,
                "public key":blockchain_obj.publicKey,
                "private key":private_Key.decode('utf-8')
            }
            sendmail(to_email=to_email , email_code=email_code,key_value=key_value,filePath=certificatepath)

            

        request.session["pptconversion1"] = str(pptconversion1)

        for slide in prs.slides:
            print("slide number %d" % i)
            i += 1
            etc_list = ["", " ", ",", " ,"]
            sentence = ""
            non_dial_src_lang = ""
            script_use = ""
            print('#9870124555')
            # if slide.shapes[0].text is not None:
            #     sentence = slide.shapes[0].text
            if slide.shapes[0].has_text_frame:
                sentence = slide.shapes[0].text
                sentence = re.sub(
                    """[!@#$%^&*()+=}{:;"'<>?/_-]""", "", sentence)
                if len(sentence) < 5:
                    continue
                non_dial_src_lang = language_detector(sentence)
                script_use = script_det(sentence)
                if non_dial_src_lang != "" and script_use != "":
                    print(i, "slidessssssssssssss")
                    print(
                        non_dial_src_lang, script_use, "languagesssssssssssssssssssssss"
                    )
                    break
            else:
                if slide.has_notes_slide:
                    text_frame = slide.notes_slide.notes_text_frame
                    if len(text_frame.text) > 0:
                        try:
                            if text_frame.text in etc_list:
                                continue
                                # print("text", text_frame.text)
                            sentence = text_frame.text
                            translator = Translator()
                            non_dial_src_lang = language_detector(sentence)
                            script_use = script_det(sentence)
                            if non_dial_src_lang != "" and script_use != "":
                                break
                        except:
                            non_dial_src_lang = ""
                            sentence = ""
                            script_use = ""
                        else:
                            break

                if sentence == "":

                    for shape in slide.shapes:
                        if not shape.has_text_frame:
                            continue
                        for paragraph in shape.text_frame.paragraphs:
                            for index, paragraph_run in enumerate(paragraph.runs):
                                try:
                                    if paragraph_run.text in etc_list:
                                        continue
                                    sentence = paragraph_run.text
                                    translator = Translator()
                                    non_dial_src_lang = language_detector(
                                        sentence)
                                    script_use = script_det(sentence)
                                    if non_dial_src_lang != "" and script_use != "":
                                        break
                                except:
                                    non_dial_src_lang = ""
                                    sentence = ""
                                    script_use = ""
                                else:
                                    break

        # slide = prs.slides[0]
        # heading = slide.shapes.title.text
        # translator = Translator()
        # non_dial_src_lang = translator.detect(heading)
        # print("00000000000000000000000000000000000000000000000000000000000000000000000000000000000000",
        #       non_dial_src_lang.lang)
        # script_use = script_det(heading)
        # print("script used: ", script_use)
        # print("The Data of formInput is:", formInput)
        request.session["script_use"] = script_use
        slang = languages.get(non_dial_src_lang)
        if slang == None:
            slang = "abc"
        context = {
            "id": user_id,
            "numPages": numPages,
            "ppt": x.upload_ppt,
            "option4": languages,
            "fileName": MyURL,
            "non_dial_src_lang": non_dial_src_lang,
            "non_dial_src_lang_full": slang,
            "author_name": author_name,
            "script_title": script_title,
            "Uppt": prs,
        }
        print("-----------------------------------------------")
        print(context)
        end_time = time.time()
        print("-------------Taken Time for input ppt processing->", end_time - start_time)
        return render(request, "conversion/pptupload.html", context)
    return render(request, "conversion/pptupload.html")


def pptDiscountHandler():
    pass



# -> Actually Running Translation and Transliteration of PPT
def convertppt(request):
    if request.method == "POST":
        print("request.session variables", )
        for key, value in request.session.items():
            print('{} => {}'.format(key, value))
        for key, value in request.POST.items():
            print('{} => {}'.format(key, value))

        try:
            x = pptconversion.objects.get(ppt_string=request.session["pptstring"])
        except:
            x = pptconversion()
            x.user_id = request.user
        print("slides number are",x.slide_count)
        try:
            if x.upload_ppt:
                print("exists ")

            else:
                x.upload_ppt = request.POST.get("fileUpload")
        except:
            x.upload_ppt = request.POST.get("fileUpload")
        source_language = request.POST.get("non_dial_src_lang")
        x.source_lang = languages[source_language]
        try:
            x.source_script = request.session["script_use"]
        except:
            x.source_script = language_script[str(x.source_lang)]

        x.target_lang = request.POST.get("nondial_dest_language")
        x.target_script = request.POST.get("dial_dest_script")
        restrict = False
        # x.sample = request.POST.get("restrict")
        if request.POST.get("restrict") == 'on':
            x.slide_count = 3
            restrict = True
        print(request.POST.get("to_be_vetted_by_lpp"), "Vetting on or off #787")


        #sample blockchain
        try:
            pptconversion1 = eval(request.session["pptconversion1"])
        except:
            pptconversion1 = {}
            if UserCredentialsForBlockchain.objects.filter(user=request.user).exists():
                with open(f"{basePath}/media/{x.upload_ppt}", 'rb') as _file:
                    hash = uploadDataToIPFSNode(_file)
                    pptconversion1["ppt_scriptFile_hash"] = hash
                    print("my_hash1", hash)
                current_datetime = datetime.datetime.now()
                pptconversion1["slide_count"] = request.POST.get("numPages")
                pptconversion1["ppt_string"] = request.POST.get("ppt_string")
                pptconversion1["script_title"] = request.POST.get("script_title")
                pptconversion1["non_dial_src_lang"] = request.POST.get("non_dial_src_lang")
                pptconversion1["author_name"] = request.POST.get("author_name")
                pptconversion1["ppt_scriptFile_path"] = f"{basePath}/media/{x.upload_ppt}"
                pptconversion1["upload_ppt"] = f"{x.upload_ppt}"

                pptconversion1["date_at"] = current_datetime.strftime(
                    "%Y-%m-%d %H:%M:%S")

            request.session["pptconversion1"] = str(pptconversion1)




        if request.POST.get("to_be_vetted_by_lpp") == "on":
            x.lpp = True
            pptconversion1["lpp"] = True
        id = x.ppt_id
        request.session["script_id"] = str(id)

        try:
            if UserCredentialsForBlockchain.objects.filter(user=request.user).exists():
                blockchain_obj = UserCredentialsForBlockchain.objects.get(
                    user=request.user)

                pptconversion1["source_lang"] = languages[source_language]
                pptconversion1["target_lang"] = request.POST.get(
                    "nondial_dest_language")
                pptconversion1["target_script"] = request.POST.get(
                    "dial_dest_script")
                pptconversion1["ppt_id"] = request.session["script_id"]

                UserId = blockchain_obj.user_id
                Project = request.session["script_id"]
                # Project = id
                Data = str(pptconversion1)
                userPrivateKey = blockchain_obj.privateKey
                userkey = decryptionOfPrivate(userPrivateKey)
                hash = UploadPPTConversionData(
                    OWNER_KEY,blockchain_obj.publicKey, UserId, Project, Data)
                print("my_tx_hash", hash)
        except:
            pass
        if x.slide_count <= 3:
            x.amount = 0
            x.save()
            # with open(rf"{basePath}/ideamall/templates/ideamall/body.txt") as f:
            #     body = f.read()

            # context_email = {
            #     "Date": date.today(),
            #     "Name": x.user_id.email,
            #     "emailcode": "",
            #     "heading1": "Thank you!",
            #     "heading2": " for using ppt conversion service "
            #     + " you will get notification whenever the conversation completes",
            #     "body": body,
            # }
            # whomtosend, titleofmail, dateofemail, context\
            # sendemail(
            #     x.user_id.email,
            #     "Thankyou for using service",
            #     date.today(),
            #     context_email,
            #     EMAIL_HOST_USER,
            # ).start()
            print("Starting conversion of ppt")
            print(x.upload_ppt)
            ppt_conversion(x.ppt_id, request, restrict).start()
            try:
                del request.session["pptstring"]
            except:
                pass
            sendmail(to_email=[x.user_id.email], email_code='CP4')
            sendmail(to_email=[x.user_id.email], email_code='CP9')
            print('is the email working for ppt')

            print("ending conversion of ppt")
            return render(request, "conversion/thanksppt.html")
            # Blockchain implement


        if request.POST.get("to_be_vetted_by_lpp") == "on":
            lpp_available = "yes"
            total_amount = round(int(float(pricing_data('PPT Conversion', 4))) * x.slide_count, 2)
        else:
            lpp_available = "no"
            total_amount = round(int(float(pricing_data('PPT Conversion', 2))) * x.slide_count, 2)

        print('All discounts ----------------------', centralPayment_get_discounts(request, total_amount))
        pricelist = centralPayment_get_discounts(request, total_amount)
        context = {}
        context["ppt_id"] = id
        request.session["ppt_id"] = str(id)
        
        context["sub_total"] = round(total_amount, 2)
        context["membership_discount"] = pricelist["membership_discount_calculate"]
        context["staff_discount"] = pricelist["staff_discount_calculate"]
        context["student_discount"] = pricelist["student_discount_calculate"]
        context["early_bird_discount"] = pricelist["early_bird_calculate"]
        context['total_discount'] = pricelist['total_discount']
        context['net_service_charge'] = pricelist['net_service_charge']
        context["total_payable"] = pricelist["total_payable"]
        context["gst_calculate"] = pricelist["gst_calculate"]
        context["gross_payable"] = pricelist["gross_payable"]
        if request.POST.get("to_be_vetted_by_lpp") == "on":
            calc = round(float((float(pricing_data("PPT Conversion", 4)) - float(pricing_data("PPT Conversion", 2))) / float(pricing_data("PPT Conversion", 4))) * pricelist["total_payable"], 2)
            request.session['lppamount_after_discount'] = calc
        
        if not privilegedUser1.objects.filter(user=request.user, is_active="yes").exists():
            context["monthly_membership"] = 1
        





        #old code to be destoyed 


        # context = {}
        # context["ppt_id"] = id
        # request.session["ppt_id"] = str(id)
        # print("ending conversion of ppt1")
        # # payment calculation for presentation
        # pdiscount = 1
        # sdiscount = 1
        # mdiscount = 1 - RUNNING_DISCOUNT_CONVERSION / 100

        # # if not privilegedUser1.objects.filter(
        # #     user=request.user, is_active="yes"
        # # ).exists():

        # #     messages.success(request, "Become privileged member")
        # #     return redirect("payment")
        # # return True

        # if not privilegedUser1.objects.filter(
        #     user=request.user, is_active="yes"
        # ).exists():
        #     # messages.success(request, "Become privileged member")
        #     # return redirect("payment")
        #     # request.session["directly_pay_monthly"] = 1
        #     context = {"directly_pay_monthly": 1}
        # try:
        #     memberType = privilegedUser1.objects.get(
        #         user=request.user, is_active="yes"
        #     ).memberType
        #     print("ending conversion of ppt2")
        #     if memberType:
        #         if memberType == "normal":
        #             pdiscount = 1
        #             context["pdiscount"] = 0
        #         elif memberType == "yearly":
        #             pdiscount = 1 - YEARLY_MEMBER_ADDITIONAL / 100
        #             context["pdiscount"] = YEARLY_MEMBER_ADDITIONAL
        #         elif memberType == "Life Member":
        #             pdiscount = 1 - LIFE_MEMBER_ADDITIONAL / 100
        #             context["pdiscount"] = LIFE_MEMBER_ADDITIONAL
        # except:
        #     pdiscount = 1
        #     # sdiscount = 1
        #     context["pdiscount"] = 0
        # print("ending conversion of ppt3")
        # if User.objects.get(id=request.user.id).is_staff:
        #     sdiscount = 1 - EMPLOY_DISCOUNT / 100
        # else:
        #     sdiscount = 1
        # if request.POST.get("to_be_vetted_by_lpp") == "on":
        #     lpp_available = "yes"
        #     amt = x.slide_count * CONVERSION_PER_PAGE
        #     context["total"] = round(amt, 2)

        #     lppamt = (x.slide_count * CONVERSION_PER_PAGE) + (
        #         x.slide_count * LPP_PER_PAGE
        #     )
        #     context["onlylppfee"] = round((x.slide_count * LPP_PER_PAGE), 2)
        #     amount_to_be_given_to_lpp = round(
        #         mdiscount * context["onlylppfee"] * pdiscount * sdiscount, 2
        #     )
        #     context["subtotal"] = round(lppamt, 2)
        #     context["amount"] = round(
        #         mdiscount * lppamt * pdiscount * sdiscount, 2)
        #     x.amount = context["amount"]
        #     request.session["pptamount"] = context["amount"]
        #     context["discount"] = lppamt - context["amount"]
        #     request.session["pptdiscount"] = lppamt - context["amount"]
        #     request.session["lppamount_after_discount"] = amount_to_be_given_to_lpp
        #     request.session["total_amount1"] = context["subtotal"]
        #     request.session["amount1"] = context["amount"]
        #     request.session["discount1"] = context["discount"]
        #     print("ending conversion of ppt4")
        # else:
        #     print("ending conversion of ppt5")
        #     lpp_available = "no"
        #     amt = x.slide_count * CONVERSION_PER_PAGE
        #     context["total"] = round(amt, 2)
        #     context["subtotal"] = round(amt, 2)
        #     context["amount"] = round(
        #         mdiscount * amt * pdiscount * sdiscount, 2)
        #     context["discount"] = amt - context["amount"]
        #     x.amount = context["amount"]
        #     request.session["total_amount1"] = context["total"]
        #     request.session["amount1"] = context["amount"]
        #     request.session["discount1"] = context["discount"]
        #     request.session["pptamount"] = context["amount"]
        #     request.session["pptdiscount"] = amt - context["amount"]
        # print("ending conversion of ppt6")
        # context["conversion_per_page"] = CONVERSION_PER_PAGE
        # context["lpp_per_page"] = LPP_PER_PAGE
        # context["running_discount_conversion"] = RUNNING_DISCOUNT_CONVERSION
        # context["employ_discount"] = EMPLOY_DISCOUNT
        # context["yearly_member_additional"] = YEARLY_MEMBER_ADDITIONAL
        # context["life_member_additional"] = LIFE_MEMBER_ADDITIONAL
        # context["value_after_rd"] = round(
        #     ((context["running_discount_conversion"] / 100)) * context["subtotal"], 2)
        # context["value_after_td"] = round(((context["employ_discount"] / 100)) * (
        #     1 - (context["running_discount_conversion"] / 100)) * context["subtotal"], 2)
        # context["value_after_md"] = round(((context["pdiscount"] / 100)) * (1 - (context["employ_discount"] / 100)) * (
        #     1 - (context["running_discount_conversion"] / 100)) * context["subtotal"], 2)
        context["restrict_to_five"] = "no"
        context["lpp_available"] = lpp_available.upper()
        context["numPages"] = x.slide_count
        # context["script_title"] = x.script_title
        context["ndial_src"] = x.source_lang
        context["ndial_dest"] = x.target_lang
        context["dial_dest_script"] = x.target_script
        context["dial_src_script"] = x.source_script
        context["ppt_title"] = request.session["slide_title"].split(".")[0]
        print("ending conversion of ppt7")
        x.save()
        print("ending conversion of ppt8")
        print("kuch na kaho3456")
        try:
            wall = Wallet.objects.get(user=request.user)
            context["balance"] = round(wall.balance, 2)
            print('Kya na kaho3456')
        except:
            context["balance"] = -1
        with open(f"{basePath}/MNF/json_keys/conversionRates.json") as c:
            curr = json.load(c)
            try:
                rate = curr["rates"]["INR"]
                # c = CurrencyRates()
                # rate = c.get_rate("USD", str(currency.upper()))
                print("kuch na kaho3456789")
            except Exception as e:
                print("checkout error", e)
                rate = 80
        context["rate"] = rate

        user = User.objects.get(id=request.user.id)
        str1 = str(datetime.datetime.now()).split("-")
        date_at = f'{str1[2][0:2]} - {str1[1]} - {str1[0]}'
        context['date_at'] = date_at
        try:
            cd = centralDatabase.objects.get(user_id=request.user)
            name = cd.firstName if cd.firstName else user.username
            email_id = cd.email if cd.email else user.email
            # phone_number = str(cd.countryCode) + str(cd.contact) if cd.contact else "N/A"
            # address = cd.address if cd.address else "N/A"
        except:
            user = User.objects.get(id=request.user.id)
            name = user.username
            email_id = user.email
            # phone_number = "N/A"
            # address = "N/A"

        context["name"] = name
        context["email_id"] = email_id
        context["phone_number"] = pricelist['contact'] if pricelist['contact'] else "N/A"
        context["address"] = pricelist['address'] if pricelist['address'] else "N/A"
        request.session['amount'] = context['gross_payable']
        request.session["discount"] = context["total_discount"]
        request.session["subtotal"] = context["sub_total"]


        print("kuch na kaho34560000")
        return render(request, "conversion/invoice_pptconversion.html", context)


# -> For Deleting your PPT
def delete_ppt(request, id):
    # if request.method == "POST":
    #     x = pptconversion.objects.get(ppt_id=request.POST.get("pptid"))
    #     print(x, 'did i do that or what?')
    #     sendmail(to_email=[request.user.email],email_code='CP7')
    sendmail(to_email=[request.user.email], email_code='CP7')
    # pptconversion.objects.get(ppt_id=id).delete()
    if UserCredentialsForBlockchain.objects.filter(user=request.user).exists():
        try:
            blockchain_obj = UserCredentialsForBlockchain.objects.get(
                user=request.user)
            userkey = decryptionOfPrivate(blockchain_obj.privateKey)
            print("funcation is calling.......", userkey.decode(
                'utf-8'), blockchain_obj.user_id, id)
            deletePPTConversion(OWNER_KEY,blockchain_obj.publicKey, blockchain_obj.user_id, id)
            print("funcation called......", userkey.decode(
                'utf-8'), blockchain_obj.user_id, id)
            pptconversion.objects.get(ppt_id=id).delete()
            return HttpResponseRedirect("/conversion/view_conversion")
        except:
            pptconversion.objects.get(ppt_id=id).delete()
            return HttpResponseRedirect("/conversion/view_conversion")

    else:
        pptconversion.objects.get(ppt_id=id).delete()
        return HttpResponseRedirect("/conversion/view_conversion")


# -> Feedback on Conversion of PPT by User
def feedback_ppt(request):
    if request.method == "POST":
        x = pptconversion.objects.get(ppt_id=request.POST.get("pptid"))
        if (
            str(request.POST.get("error_text")) == " "
            or str(request.POST.get("error_text")) == ""
        ):
            x.error_faced_feedback = ""
        else:
            x.error_faced_feedback = str(request.POST.get("error_text"))
        if request.POST.get("rating") == " " or request.POST.get("rating") == "":
            x.translation_accuracy_rate = 0
        else:
            x.translation_accuracy_rate = int(request.POST.get("rating"))
        x.improvement_feedback = str(request.POST.get("improvement"))
        x.attention_feedback = str(request.POST.get("text"))
        try:
            x.exp_rate = int(request.POST.get("accurate"))
        except:
            pass
        try:
            x.content_accuracy_rate = int(request.POST.get("language"))
        except:
            pass
        x.save()
        with open(rf"{basePath}/ideamall/templates/ideamall/body.txt") as f:
            body = f.read()

        context_email = {
            "Date": date.today(),
            "Name": x.user_id.email,
            "emailcode": "",
            "heading1": "Thank you!",
            "heading2": " your feedback is very important for us, thankyou for feedback ",
            "body": body,
        }
        # whomtosend, titleofmail, dateofemail, context\
        # sendemail(
        #     x.user_id.email,
        #     "Feedback recieved",
        #     date.today(),
        #     context_email,
        #     EMAIL_HOST_USER,
        # ).start()
        sendmail(to_email=[x.user_id.email], email_code='CP8')
        print("feedback of ppt mail")
        return redirect("view_conversion")

def ppt_tutorial(request):
    return render(request,"conversion/Tutorial_video.html")



@login_required
def Get_Existing_Scripts(request):
    scripts = MNFScriptDatabase.objects.filter(user_id = request.user.id).values_list('script_id', 'script_file_path')
    if len(scripts) == 0:
        return JsonResponse({"status":"Success", })
    existing_scripts = {}
    for script in scripts:
        existing_scripts[str((((str(script[1]).split("/"))[-1]).split("."))[0])] = str(script[0])
    return JsonResponse(existing_scripts)
# <!--            document.getElementById('import').action = "{% url 'load_existingscript' id11 %}"-->
@login_required
def load_existing_script(request, id):
    # -> Loading Script
    script = MNFScriptDatabase.objects.get(user_id = request.user, script_id = id)
    MyURL = "/media/" + str(((script.script_file_path).split("/media/"))[-1])
    if script.option3 and script.option4 and script.option5 and script.option6:
        option3 = script.option3
        option4 = script.option4
        option5 = script.option5
        option6 = script.option6
    else:
        formInput = getInputs(request, str(BASE_DIR) + MyURL)
        option3 = formInput[4]
        option4 = formInput[5]
        option5 = formInput[6]
        option6 = formInput[7]
    sampleList = SampleScript.objects.all()
    with open(f"{basePath}/MNF/json_keys/language_pairs.json") as c:
        language_pairs = json.load(c)
    with open(f"{basePath}/MNF/json_keys/script_pairs.json") as c:
        script_pairs = json.load(c)
    context = {
        "id": script.id,
        "numPages": script.numPages,
        "fileName": MyURL,
        "non_dial_src_script": script.nondial_src_script,
        "author_name": script.author_name,
        "script_title": (((str(script.script_title).split("/"))[-1]).split("."))[0],
        "UScript": "UScript",
        "dial_src_script": script.dial_src_script,
        "dial_src_lang": script.dial_src_language,
        "dial_src_lang_full": languages.get(script.dial_src_language),
        "non_dial_src_lang_full": languages.get(script.nondial_src_language),
        "non_dial_src_lang": script.nondial_src_language,
        "list": sampleList,
        "option3": option3,
        "option4": option4,
        "option5": option5,
        "option6": option6,
        "language_pairs": language_pairs,
        "default_script": language_script,
        "script_pairs": script_pairs,
        "existing_script": True,
    }
    print("Redirecting to 2nd Page")
    return render(request, "conversion/conversion.html", context)