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