5402 lines
237 KiB
Python
Executable File
5402 lines
237 KiB
Python
Executable File
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 lpp.models import LPPTASKDatabase
|
|
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, HttpResponseBadRequest
|
|
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, SampleScript
|
|
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
|
|
from centralisedFileSystem.models import Script
|
|
from scriptAudit.models import ScriptAuditModel
|
|
|
|
|
|
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
|
|
import cProfile
|
|
|
|
|
|
|
|
|
|
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):
|
|
original_stdout = sys.stdout
|
|
# 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":
|
|
start_time = time.time()
|
|
# 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")
|
|
sys.stdout = original_stdout
|
|
print("Time Taken For Input Processing is ->", time.time() - start_time)
|
|
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
|
|
# @cProfile.run
|
|
def make_conversion(request):
|
|
|
|
# original_stdout = sys.stdout
|
|
|
|
|
|
|
|
# Your view logic here
|
|
|
|
|
|
|
|
if request.method == "POST":
|
|
original_stdout = sys.stdout
|
|
# start_time = time.time()
|
|
f = open(f"/home/user/mnf/project/MNF/log/debugconversion_{(((str(request.POST.get('script_file_path')).split('/'))[-1]).split('.'))[0]}.txt", "w")
|
|
profile = cProfile.Profile()
|
|
profile.enable()
|
|
sys.stdout = f
|
|
print("Conversion Process Started")
|
|
now = datetime.datetime.now()
|
|
|
|
current_time = now.strftime("%H:%M:%S")
|
|
print(current_time)
|
|
|
|
"""Initializing Variables"""
|
|
script_file_path = request.POST.get("script_file_path")
|
|
request_id = request.POST.get("request_id")
|
|
str1 = str(script_file_path)
|
|
if str1[41:45] == "user":
|
|
script_file_path = "/home/" + str(str1[41:])
|
|
script_id = request.POST.get("script_id")
|
|
dial_conv_script = request.POST.get("dial_conv_script")
|
|
dial_src_lang = request.POST.get("dial_src_lang")
|
|
non_dial_src_lang = request.POST.get("non_dial_src_lang")
|
|
dial_src_script = request.POST.get("dial_src_script")
|
|
restrict_to_five = request.POST.get("restrict_to_five")
|
|
option3 = request.POST.get("option3")
|
|
option4 = request.POST.get("option4")
|
|
option5 = request.POST.get("option5")
|
|
option6 = request.POST.get("option6")
|
|
# -> Saving options 3,4,5,6
|
|
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()
|
|
|
|
|
|
"""Audit Code starts here"""
|
|
|
|
print("Conversion Auditing is starting")
|
|
scripttt = script_file_path
|
|
name_script = str(((((scripttt).split("/"))[-1]).split("."))[0])
|
|
print("name of script", name_script)
|
|
print("sample script", request.POST.get("sample_id"))
|
|
print("existing_script", request.session.get("existing_script"))
|
|
"""if file is not a sample script and not a existing script then only audit it"""
|
|
if not request.session.get('existing_script') and not request.POST["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,
|
|
)
|
|
audit_id = result.get("script", {}).get("id")
|
|
while True:
|
|
try:
|
|
status = ScriptAuditModel.objects.get(
|
|
script=Script.objects.get(id=audit_id)).status
|
|
if status == "SUCCESS":
|
|
to_email = [request.user.email]
|
|
email_code = 'SB1'
|
|
sendmail(to_email=to_email, email_code=email_code)
|
|
break
|
|
elif status == "FAILURE":
|
|
to_email = [request.user.email]
|
|
email_code = 'SB2'
|
|
sendmail(to_email=to_email, email_code=email_code)
|
|
print(
|
|
"Script Audit failed due to some internal error."
|
|
" If you have made any payment for conversion "
|
|
"that will be refunded")
|
|
# email for failure
|
|
to = request.user.email
|
|
key_value = {
|
|
"User": request.user.username,
|
|
}
|
|
sendmail(to_email=[to], email_code="PP21", key_value=key_value)
|
|
# auto refund code
|
|
auto_refund(ScriptTranslations.objects.get(
|
|
translation_id=request.session.get('translation_id', None)).central_payment_id)
|
|
return JsonResponse({}, status=505)
|
|
elif status == "STARTED" or status == "PENDING":
|
|
pass
|
|
except:
|
|
pass
|
|
time.sleep(1)
|
|
file_path_ = filesystem.get_file_path(
|
|
audit_id, "script-csv")
|
|
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)
|
|
dataframe = df
|
|
list_of_lists = dataframe.values.tolist()
|
|
print("Audit Done")
|
|
|
|
|
|
elif request.POST.get("sample_id"):
|
|
sample_script = SampleScript.objects.get(sample_id=request.GET["sample_id"])
|
|
if sample_script.audit_id:
|
|
audit_id = sample_script.audit_id
|
|
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()
|
|
else:
|
|
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,
|
|
)
|
|
audit_id = result.get("script", {}).get("id")
|
|
while True:
|
|
try:
|
|
status = ScriptAuditModel.objects.get(
|
|
script=Script.objects.get(id=audit_id)).status
|
|
if status == "SUCCESS":
|
|
to_email = [request.user.email]
|
|
email_code = 'SB1'
|
|
sendmail(to_email=to_email, email_code=email_code)
|
|
break
|
|
elif status == "FAILURE":
|
|
to_email = [request.user.email]
|
|
email_code = 'SB2'
|
|
sendmail(to_email=to_email, email_code=email_code)
|
|
# email for failure
|
|
to = request.user.email
|
|
key_value = {
|
|
"User": request.user.username,
|
|
}
|
|
sendmail(to_email=[to], email_code="PP21", key_value=key_value)
|
|
# auto refund code
|
|
auto_refund(ScriptTranslations.objects.get(
|
|
translation_id=request.session.get('translation_id', None)).central_payment_id)
|
|
return JsonResponse({}, status=505)
|
|
elif status == "STARTED" or status == "PENDING":
|
|
pass
|
|
except:
|
|
pass
|
|
time.sleep(1)
|
|
file_path_ = filesystem.get_file_path(
|
|
audit_id, "script-csv")
|
|
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)
|
|
dataframe = df
|
|
list_of_lists = dataframe.values.tolist()
|
|
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
|
|
file_path_ = filesystem.get_file_path(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)
|
|
dataframe = df
|
|
list_of_lists = dataframe.values.tolist()
|
|
else:
|
|
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,
|
|
)
|
|
audit_id = result.get("script", {}).get("id")
|
|
while True:
|
|
try:
|
|
status = ScriptAuditModel.objects.get(
|
|
script=Script.objects.get(id=audit_id)).status
|
|
if status == "SUCCESS":
|
|
to_email = [request.user.email]
|
|
email_code = 'SB1'
|
|
sendmail(to_email=to_email, email_code=email_code)
|
|
break
|
|
elif status == "FAILURE":
|
|
to_email = [request.user.email]
|
|
email_code = 'SB2'
|
|
sendmail(to_email=to_email, email_code=email_code)
|
|
# email for failure
|
|
to = request.user.email
|
|
key_value = {
|
|
"User": request.user.username,
|
|
}
|
|
sendmail(to_email=[to], email_code="PP21", key_value=key_value)
|
|
# auto refund code
|
|
auto_refund(ScriptTranslations.objects.get(
|
|
translation_id=request.session.get('translation_id', None)).central_payment_id)
|
|
return JsonResponse({}, status=505)
|
|
elif status == "STARTED" or status == "PENDING":
|
|
pass
|
|
except:
|
|
pass
|
|
time.sleep(1)
|
|
file_path_ = filesystem.get_file_path(
|
|
audit_id, "script-csv")
|
|
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)
|
|
dataframe = df
|
|
list_of_lists = dataframe.values.tolist()
|
|
print("Audit Done")
|
|
|
|
"""Audit Code ends here"""
|
|
sys.stdout = f
|
|
|
|
|
|
|
|
"""Translation Code Starts Here"""
|
|
# sys.stdout = original_stdout
|
|
print("Conversion Translation is Starting")
|
|
# - Convert Process Start Mail
|
|
to = request.user.email
|
|
key_value = {"User": request.user.username}
|
|
sendmail(to_email=[to], email_code="PP17", key_value=key_value)
|
|
|
|
# subject = "All Good Email test1"
|
|
# 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)
|
|
|
|
try:
|
|
translate_function(
|
|
request,
|
|
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.POST.get("centralised"),
|
|
request.POST.get("sample_id"),
|
|
request.POST.get("sample_title"),
|
|
)
|
|
except Exception as e:
|
|
print("Error in Conversion is:", e)
|
|
print("Script translation failed due to some code error. If you have made any payment for conversion"
|
|
" that will be refunded")
|
|
# email for failure
|
|
to = request.user.email
|
|
key_value = {
|
|
"User": request.user.username,
|
|
}
|
|
sendmail(to_email=[to], email_code="PP21", key_value=key_value)
|
|
# auto refund code
|
|
auto_refund(ScriptTranslations.objects.get(
|
|
translation_id=request.session.get('translation_id', None)).central_payment_id)
|
|
# f.close()
|
|
return JsonResponse({}, status=505)
|
|
|
|
"""Translation Code Ends Here"""
|
|
|
|
|
|
|
|
|
|
"""Juggernaut Payment Updation"""
|
|
# sys.stdout = original_stdout
|
|
if request.session.get("juggernaut_pages_deduction"):
|
|
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()
|
|
|
|
"""Juggernaut Payment Updation Done"""
|
|
|
|
|
|
|
|
|
|
"""Blockchain Upload Starts here"""
|
|
# sys.stdout = original_stdout
|
|
scriptconversion = {}
|
|
try:
|
|
current_datetime = datetime.datetime.now()
|
|
if UserCredentialsForBlockchain.objects.filter(user=request.user).exists():
|
|
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}"
|
|
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
|
|
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)
|
|
tx_id = UploadConversionData(OWNER_KEY, blockchain_obj.publicKey, UserId, str(Project), Data)
|
|
print("blockchain script conversion 6")
|
|
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)
|
|
|
|
"""Blockchain Upload Ends here"""
|
|
|
|
|
|
|
|
|
|
"""Translation Completion mail here"""
|
|
# sys.stdout = original_stdout
|
|
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)
|
|
|
|
"""Translation Completion mail done"""
|
|
|
|
|
|
|
|
|
|
"""Vetting Process if Choosen"""
|
|
# sys.stdout = original_stdout
|
|
if request.POST.get("to_be_vetted_by_lpp") == "on":
|
|
obj = ScriptTranslations.objects.get(translation_id=request.session.get('translation_id', None))
|
|
obj.lpp = True
|
|
obj.save()
|
|
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")
|
|
|
|
"""Vetting Process Done"""
|
|
|
|
|
|
|
|
|
|
|
|
print("Script Translated successfully and Sent for Vetting if chosen")
|
|
profile.disable()
|
|
profile.print_stats(sort='cumulative')
|
|
f.close()
|
|
sys.stdout = original_stdout
|
|
|
|
# print("Time Taken For Conversion Processing is ->", time.time() - start_time)
|
|
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["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)
|
|
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["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)
|
|
try:
|
|
s = MNFScriptDatabase.objects.get(user_id=request.user, script_id=script_id)
|
|
except:
|
|
s = MNFScriptDatabase()
|
|
s.user_id = request.user
|
|
s.script_id = script_id
|
|
s.script_title = script_title
|
|
s.author_name = request.user.first_name
|
|
# s.dial_dest_language = dial_dest_language
|
|
# s.dial_dest_script = dial_dest_script
|
|
# s.nondial_dest_language = nondial_dest_language
|
|
# s.dual_dial_script = dual_dial_script
|
|
s.script_file_path = script_file_path
|
|
# save central payment details in your database
|
|
# s.payment_order_id = "monthly_user"
|
|
# s.central_payment_id = context["central_pay_id"]
|
|
# s.payment_intent_id = payment_intent_id
|
|
s.nondial_src_script = non_dial_src_script
|
|
s.dial_src_script = dial_src_script
|
|
s.dial_src_language = dial_src_lang
|
|
s.nondial_src_language = non_dial_src_lang
|
|
# s.nondial_dest_script = nondial_dest_script
|
|
s.save()
|
|
|
|
translation_instance = ScriptTranslations()
|
|
translation_instance.user_id = request.user
|
|
translation_instance.script_link_id = s
|
|
translation_instance.nondial_dest_language = nondial_dest_language
|
|
translation_instance.nondial_dest_script = nondial_dest_script
|
|
translation_instance.dial_dest_language = language_2_code[str(dial_dest_language)]
|
|
translation_instance.dial_dest_script = dial_dest_script
|
|
translation_instance.dual_dial_script = dual_dial_script
|
|
translation_instance.payment_order_id = "Institutional User"
|
|
# translation_instance.central_payment_id = request.session["central_pay_id"]
|
|
translation_instance.save()
|
|
request.session['translation_id'] = str(translation_instance.translation_id)
|
|
|
|
context = {
|
|
"script_id": script_id,
|
|
"script_title": script_title,
|
|
"script_file_path": script_file_path,
|
|
"dial_conv_script": dial_conv_script,
|
|
"nondial_dest_language": nondial_dest_language,
|
|
"dial_dest_language": dial_dest_language,
|
|
"dial_dest_script": dial_dest_script,
|
|
"dial_src_lang": dial_src_lang,
|
|
"non_dial_src_lang": non_dial_src_lang,
|
|
"dial_src_script": dial_src_script,
|
|
"dual_dial_script": dual_dial_script,
|
|
"total_amount": total_amount,
|
|
"to_be_vetted_by_lpp": to_be_vetted_by_lpp,
|
|
"restrict_to_five": "no",
|
|
"option3": option3,
|
|
"option4": option4,
|
|
"option5": option5,
|
|
"option6": option6,
|
|
}
|
|
# return redirect('conversion')
|
|
# return JsonResponse(context)
|
|
return render(request, "conversion/thanksconversion.html", context)
|
|
|
|
|
|
|
|
# -> Conversion Stripe Payment Done Message
|
|
def paymentDoneC(request):
|
|
|
|
if request.method == "GET":
|
|
|
|
script_id = request.session["script_id"]
|
|
script_title = request.session["script_title"]
|
|
script_file_path = request.session["script_file_path"]
|
|
dial_conv_script = request.session["dial_conv_script"]
|
|
nondial_dest_language = request.session["nondial_dest_language"]
|
|
dial_dest_language = request.session["dial_dest_language"]
|
|
dial_dest_script = request.session["dial_dest_script"]
|
|
dial_src_lang = request.session["dial_src_lang"]
|
|
non_dial_src_lang = request.session["non_dial_src_lang"]
|
|
dial_src_script = request.session["dial_src_script"]
|
|
non_dial_src_script = request.session["non_dial_src_script"]
|
|
dual_dial_script = request.session["dual_dial_script"]
|
|
nondial_dest_script = request.session["nondial_dest_script"]
|
|
if request.session.get("want_to_be_vetted"):
|
|
total_amount = request.session["amount"]
|
|
else:
|
|
total_amount = request.session["amount"]
|
|
to_be_vetted_by_lpp = request.session["want_to_be_vetted"]
|
|
option3 = request.session["option3"]
|
|
option4 = request.session["option4"]
|
|
option5 = request.session["option5"]
|
|
option6 = request.session["option6"]
|
|
# payment_intent_id = request.session["payment_intent_id"]
|
|
# pi = stripe.PaymentIntent.retrieve(payment_intent_id)
|
|
print("all get 8989 variables", request.GET.items())
|
|
for key, value in request.GET.items():
|
|
print(rf'{key}: {value}')
|
|
response = {
|
|
"id": request.GET.get("payment_intent"),
|
|
"client_secret": request.GET.get("payment_intent_client_secret"),
|
|
"status": request.GET.get("redirect_status"),
|
|
}
|
|
callback_content = callback(response, request)
|
|
if callback_content['payment_status'] == "success":
|
|
if request.session["pay_with_wallet"] == "yes":
|
|
# deduction_for_sep_wall(request)
|
|
wall = Wallet.objects.get(user=request.user)
|
|
# for key, value in request.session.items():
|
|
# print('{} => {}'.format(key, value))
|
|
print("----------------amount", request.session["pay_wallet_deduction"])
|
|
print("----------------rate", request.session["CurrencyRate"])
|
|
print("final balance", round(wall.balance, 2) - (
|
|
round(request.session["pay_wallet_deduction"], 2)))
|
|
wall.balance = round(wall.balance, 2) - (
|
|
round(request.session["pay_wallet_deduction"], 2))
|
|
wall.save()
|
|
|
|
# c = conversionPayment()
|
|
try:
|
|
s = MNFScriptDatabase.objects.get(user_id=request.user, script_id=script_id)
|
|
except:
|
|
s = MNFScriptDatabase()
|
|
s.user_id = request.user
|
|
s.script_id = script_id
|
|
s.user_id = request.user
|
|
s.script_id = script_id
|
|
s.script_title = script_title
|
|
s.author_name = request.user.first_name
|
|
# s.dial_dest_language = dial_dest_language
|
|
# s.dial_dest_script = dial_dest_script
|
|
# s.nondial_dest_language = nondial_dest_language
|
|
# s.dual_dial_script = dual_dial_script
|
|
s.script_file_path = script_file_path
|
|
# save central payment details in your database
|
|
# s.payment_order_id = request.session["payment_order_id"]
|
|
# s.central_payment_id = request.session["central_payment_id"]
|
|
# s.payment_intent_id = payment_intent_id
|
|
s.nondial_src_script = non_dial_src_script
|
|
s.dial_src_script = dial_src_script
|
|
s.dial_src_language = dial_src_lang
|
|
s.nondial_src_language = non_dial_src_lang
|
|
# s.nondial_dest_script = nondial_dest_script
|
|
# try:
|
|
# if request.session["is_juggernaut_used"]:
|
|
# s.is_juggernaut_used = True
|
|
# s.languages_juggernaut = request.session['languages_juggernaut']
|
|
# except:
|
|
# pass
|
|
# s.save()
|
|
# try:
|
|
# if request.session["juggernaut_pages_deduction"]:
|
|
# update_juggernaut(request, user_id=request.user.id, service_name="conversion",
|
|
# conversion_pages=int(request.session["juggernaut_pages_deduction"]), associated_project=s, translation_language=str(dial_dest_language))
|
|
# except Exception as e:
|
|
# print("Error is: ", e)
|
|
|
|
|
|
translation_instance = ScriptTranslations()
|
|
translation_instance.user_id = request.user
|
|
translation_instance.script_link_id = s
|
|
translation_instance.nondial_dest_language = nondial_dest_language
|
|
translation_instance.nondial_dest_script = nondial_dest_script
|
|
translation_instance.dial_dest_language = language_2_code[str(dial_dest_language)]
|
|
translation_instance.dial_dest_script = dial_dest_script
|
|
translation_instance.dual_dial_script = dual_dial_script
|
|
translation_instance.payment_order_id = request.session["payment_order_id"]
|
|
translation_instance.central_payment_id = request.session["central_payment_id"]
|
|
translation_instance.save()
|
|
print("saving")
|
|
request.session['translation_id'] = str(translation_instance.translation_id)
|
|
# -----------Adding Details to payment Details--------------------------
|
|
# currencyrate = request.session["CurrencyRate"]
|
|
# user_id = request.user
|
|
# payment_id = payment_intent_id
|
|
# services_used = "Conversion"
|
|
# script_info = s
|
|
# number_of_pages = request.session["numPages"]
|
|
# total_amounts = round(
|
|
# (request.session["numPages"] *
|
|
# CONVERSION_PER_PAGE * currencyrate),
|
|
# 2,
|
|
# )
|
|
# discount = round((request.session["discount"] * currencyrate), 2)
|
|
# amount_charged = round((total_amount * currencyrate), 2)
|
|
# gateway_fee = round(
|
|
# ((STRIPE_PLATFORM_FEE / 100) * amount_charged), 2)
|
|
# currency = "INR"
|
|
# pay_method = "Card"
|
|
# payment_status = "Success"
|
|
# payment_gateway = "Stripe"
|
|
# PaymentData.objects.create(
|
|
# user_id=user_id,
|
|
# services_used=services_used,
|
|
# payment_id=payment_id,
|
|
# script_info=script_info,
|
|
# amount_charged=amount_charged,
|
|
# total_amount=total_amounts,
|
|
# number_of_pages=number_of_pages,
|
|
# gateway_fee=gateway_fee,
|
|
# discount=discount,
|
|
# currency=currency,
|
|
# pay_method=pay_method,
|
|
# payment_status=payment_status,
|
|
# payment_gateway=payment_gateway,
|
|
# )
|
|
|
|
# c.pid = privilegedUser1.objects.get(user= request.user)
|
|
# c.script_title = script_title
|
|
# c.script_id = script_id
|
|
# c.to_be_vetted_by_lpp = to_be_vetted_by_lpp
|
|
# c.payment_intent_id = payment_intent_id
|
|
# c.total_amount = str(total_amount)
|
|
# c.script_file_path = script_file_path
|
|
# c.has_paid = 'yes'
|
|
# c.save()
|
|
context = {
|
|
"script_id": script_id,
|
|
"script_title": script_title,
|
|
"script_file_path": script_file_path,
|
|
"dial_conv_script": dial_conv_script,
|
|
"nondial_dest_language": nondial_dest_language,
|
|
"dial_dest_language": dial_dest_language,
|
|
"dial_dest_script": dial_dest_script,
|
|
"dial_src_lang": dial_src_lang,
|
|
"non_dial_src_lang": non_dial_src_lang,
|
|
"dial_src_script": dial_src_script,
|
|
"dual_dial_script": dual_dial_script,
|
|
"total_amount": total_amount,
|
|
"to_be_vetted_by_lpp": to_be_vetted_by_lpp,
|
|
"restrict_to_five": "no",
|
|
"option3": option3,
|
|
"option4": option4,
|
|
"option5": option5,
|
|
"option6": option6,
|
|
}
|
|
to = request.user.email
|
|
key_value = {
|
|
"User": request.user.username,
|
|
}
|
|
sendmail(to_email=[to], email_code="PP19", key_value=key_value)
|
|
return render(request, "conversion/thanksconversion.html", context)
|
|
else:
|
|
# subject = "Something really went wrong"
|
|
# from_email = settings.EMAIL_HOST_USER
|
|
# to = request.user.email
|
|
# context_2 = {
|
|
# "Name": request.user.email,
|
|
# "service_name": "Conversion",
|
|
# }
|
|
# mnfnsendemail(
|
|
# to, subject, "payment/templates/payments/MR24.html", context_2, from_email)
|
|
|
|
to = request.user.email
|
|
key_value = {
|
|
"User": request.user.username,
|
|
}
|
|
sendmail(to_email=[to], email_code="PP21", key_value=key_value)
|
|
return render(request, "payments/failed.html")
|
|
|
|
# -> Conversion Razorpay Payment Done Message
|
|
|
|
|
|
def paymentDoneC_RazorPay(request):
|
|
print("po")
|
|
print("PAyment Done Razorpay -> ", request.POST)
|
|
# print("PAyment Done Razorpay -> ", request.POST.data, "444")
|
|
keyID = request.session["keyID"]
|
|
keySecret = request.session["keySecret"]
|
|
if request.method == "POST":
|
|
script_id = request.session["script_id"]
|
|
script_title = request.session["script_title"]
|
|
script_file_path = request.session["script_file_path"]
|
|
dial_conv_script = request.session["dial_conv_script"]
|
|
nondial_dest_language = request.session["nondial_dest_language"]
|
|
dial_dest_language = request.session["dial_dest_language"]
|
|
dial_dest_script = request.session["dial_dest_script"]
|
|
dial_src_lang = request.session["dial_src_lang"]
|
|
non_dial_src_lang = request.session["non_dial_src_lang"]
|
|
dial_src_script = request.session["dial_src_script"]
|
|
dual_dial_script = request.session["dual_dial_script"]
|
|
non_dial_src_script = request.session["non_dial_src_script"]
|
|
nondial_dest_script = request.session["nondial_dest_script"]
|
|
if request.session.get("want_to_be_vetted"):
|
|
total_amount = request.session["amount"]
|
|
else:
|
|
total_amount = request.session["amount"]
|
|
to_be_vetted_by_lpp = request.session["want_to_be_vetted"]
|
|
option3 = request.session["option3"]
|
|
option4 = request.session["option4"]
|
|
option5 = request.session["option5"]
|
|
option6 = request.session["option6"]
|
|
# razorpay_order_id = request.POST["razorpay_order_id"]
|
|
# razorpay_payment_id = request.POST["razorpay_payment_id"]
|
|
# razorpay_signature = request.POST["razorpay_signature"]
|
|
# client = razorpay.Client(auth=(keyID, keySecret))
|
|
# params_dict = {
|
|
# "razorpay_order_id": razorpay_order_id,
|
|
# "razorpay_payment_id": razorpay_payment_id,
|
|
# "razorpay_signature": razorpay_signature,
|
|
# }
|
|
# try:
|
|
# client.utility.verify_payment_signature(params_dict)
|
|
|
|
callback_context = callback(request.POST, request)
|
|
|
|
if callback_context['payment_status'] != 'success':
|
|
subject = "Something really went wrong"
|
|
from_email = settings.EMAIL_HOST_USER
|
|
to = request.user.email
|
|
context_2 = {
|
|
"Name": request.user.email,
|
|
"service_name": "Conversion",
|
|
}
|
|
mnfnsendemail(
|
|
to, subject, "payment/templates/payments/MR24.html", context_2, from_email)
|
|
return render(request, "payments/failed.html")
|
|
|
|
if request.session["pay_with_wallet"] == "yes":
|
|
# deduction_for_sep_wall(request)
|
|
wall = Wallet.objects.get(user=request.user)
|
|
# for key, value in request.session.items():
|
|
# print('{} => {}'.format(key, value))
|
|
print("----------------amount", request.session["pay_wallet_deduction"])
|
|
print("----------------rate", request.session["CurrencyRate"])
|
|
print("final balance", round(wall.balance, 2) - (round(request.session["pay_wallet_deduction"], 2)))
|
|
wall.balance = round(wall.balance, 2) - (round(request.session["pay_wallet_deduction"], 2))
|
|
wall.save()
|
|
|
|
# c = conversionPayment()
|
|
try:
|
|
s = MNFScriptDatabase.objects.get(user_id=request.user, script_id=script_id)
|
|
print("KArdunga 1")
|
|
except:
|
|
print("KArdunga 2")
|
|
s = MNFScriptDatabase()
|
|
s.user_id = request.user
|
|
s.script_id = script_id
|
|
s.user_id = request.user
|
|
s.script_id = script_id
|
|
s.script_title = script_title
|
|
s.author_name = request.user.first_name
|
|
# s.dial_dest_language = dial_dest_language
|
|
# s.dial_dest_script = dial_dest_script
|
|
# s.nondial_dest_language = nondial_dest_language
|
|
# s.dual_dial_script = dual_dial_script
|
|
s.script_file_path = script_file_path
|
|
# s.payment_intent_id = razorpay_payment_id
|
|
s.nondial_src_script = non_dial_src_script
|
|
s.dial_src_script = dial_src_script
|
|
s.dial_src_language = dial_src_lang
|
|
s.nondial_src_language = non_dial_src_lang
|
|
# s.nondial_dest_script = nondial_dest_script
|
|
s.numPages = request.session["numPages"]
|
|
# save central payment details in your database
|
|
# s.payment_order_id = request.session["payment_order_id"]
|
|
# # save central payment details in your database
|
|
# s.central_payment_id = request.session["central_payment_id"]
|
|
# try:
|
|
# if request.session["is_juggernaut_used"]:
|
|
# s.is_juggernaut_used = True
|
|
# s.languages_juggernaut = request.session['languages_juggernaut']
|
|
# except:
|
|
# pass
|
|
s.save()
|
|
translation_instance = ScriptTranslations()
|
|
translation_instance.user_id = request.user
|
|
translation_instance.script_link_id = s
|
|
translation_instance.nondial_dest_language = nondial_dest_language
|
|
translation_instance.nondial_dest_script = nondial_dest_script
|
|
translation_instance.dial_dest_language = language_2_code[str(dial_dest_language)]
|
|
translation_instance.dial_dest_script = dial_dest_script
|
|
translation_instance.dual_dial_script = dual_dial_script
|
|
# save central payment details in your database
|
|
translation_instance.payment_order_id = request.session["payment_order_id"]
|
|
translation_instance.central_payment_id = request.session["central_payment_id"]
|
|
translation_instance.save()
|
|
print("saving")
|
|
request.session['translation_id'] = str(translation_instance.translation_id)
|
|
# c.pid = privilegedUser1.objects.get(user= request.user)
|
|
# c.script_title = script_title
|
|
# c.script_id = script_id
|
|
# c.to_be_vetted_by_lpp = to_be_vetted_by_lpp
|
|
# c.payment_intent_id = razorpay_payment_id
|
|
# c.total_amount = str(total_amount)
|
|
# c.script_file_path = script_file_path
|
|
# c.has_paid = 'yes'
|
|
# c.save()
|
|
# request.session["payment_order_id"] = context["orderId"]
|
|
# request.session["central_payment_id"]
|
|
# payFetch = client.payment.fetch(razorpay_payment_id,({'expand[]':'card'}))
|
|
# if client.payment.fetch(razorpay_payment_id, {"expand[]": "card"}):
|
|
# pay_method = "CARD"
|
|
# else:
|
|
# pay_method = "NOTCard"
|
|
# # -----------Adding Details to payment Details--------------------------
|
|
# currencyrate = request.session["CurrencyRate"]
|
|
# user_id = request.user
|
|
# payment_id = razorpay_payment_id
|
|
# services_used = "Conversion"
|
|
# script_info = s
|
|
# total_amounts = round(
|
|
# (request.session["numPages"] * CONVERSION_PER_PAGE * currencyrate),
|
|
# 2,
|
|
# )
|
|
# discount = round((request.session["discount"] * currencyrate), 2)
|
|
# amount_charged = round((total_amount * currencyrate), 2)
|
|
# gateway_fee = round(
|
|
# ((RAZORPAY_PLATFORM_FEE / 100) * amount_charged), 2)
|
|
# currency = "INR"
|
|
# # pay_method = 'NOTCard'
|
|
# payment_status = "Success"
|
|
# payment_gateway = "RazorPay"
|
|
# number_of_pages = request.session["numPages"]
|
|
# print("totalamount:", total_amounts)
|
|
# print("amountcharge:", amount_charged)
|
|
# print("discount:", discount)
|
|
# PaymentData.objects.create(
|
|
# user_id=user_id,
|
|
# payment_id=payment_id,
|
|
# total_amount=total_amounts,
|
|
# services_used=services_used,
|
|
# script_info=script_info,
|
|
# discount=discount,
|
|
# amount_charged=amount_charged,
|
|
# gateway_fee=gateway_fee,
|
|
# currency=currency,
|
|
# number_of_pages=number_of_pages,
|
|
# pay_method=pay_method,
|
|
# payment_status=payment_status,
|
|
# payment_gateway=payment_gateway,
|
|
# )
|
|
# try:
|
|
# if request.session["directly_pay_monthly"]:
|
|
# lasto = privilegedUser1.objects.last()
|
|
# privilegedUser1.objects.create(
|
|
# id=int(lasto.id) + 1,
|
|
# user=user_id,
|
|
# is_active="yes",
|
|
# transactionId=payment_id,
|
|
# memberType="normal",
|
|
# months=1
|
|
# )
|
|
# del request.session['directly_pay_monthly']
|
|
# except:
|
|
# pass
|
|
# try:
|
|
# if request.session["juggernaut_pages_deduction"]:
|
|
# update_juggernaut(request, user_id=request.user.id, service_name="conversion",
|
|
# conversion_pages=int(request.session["juggernaut_pages_deduction"]),
|
|
# associated_project=s, translation_language=str(dial_dest_language))
|
|
# except Exception as e:
|
|
# print("Error is: ", e)
|
|
context = {
|
|
"script_id": script_id,
|
|
"script_title": script_title,
|
|
"script_file_path": script_file_path,
|
|
"dial_conv_script": dial_conv_script,
|
|
"nondial_dest_language": nondial_dest_language,
|
|
"dial_dest_language": dial_dest_language,
|
|
"dial_dest_script": dial_dest_script,
|
|
"dial_src_lang": dial_src_lang,
|
|
"non_dial_src_lang": non_dial_src_lang,
|
|
"dial_src_script": dial_src_script,
|
|
"dual_dial_script": dual_dial_script,
|
|
"total_amount": total_amount,
|
|
"to_be_vetted_by_lpp": to_be_vetted_by_lpp,
|
|
"restrict_to_five": "no",
|
|
"option3": option3,
|
|
"option4": option4,
|
|
"option5": option5,
|
|
"option6": option6,
|
|
}
|
|
to = request.user.email
|
|
key_value = {
|
|
"User": request.user.username,
|
|
}
|
|
sendmail(to_email=[to], email_code="PP19", key_value=key_value)
|
|
|
|
return render(request, "conversion/thanksconversion.html", context)
|
|
else:
|
|
# print("Get Request after payment is done razorpay1515")
|
|
# subject = "Something really went wrong"
|
|
# from_email = settings.EMAIL_HOST_USER
|
|
# to = request.user.email
|
|
# context_2 = {
|
|
# "Name": request.user.email,
|
|
# "service_name": "Conversion",
|
|
# }
|
|
# mnfnsendemail(
|
|
# to, subject, "payment/templates/payments/MR24.html", context_2, from_email)
|
|
# return render(request, "payments/failed.html")
|
|
to = request.user.email
|
|
key_value = {
|
|
"User": request.user.username,
|
|
}
|
|
sendmail(to_email=[to], email_code="PP21", key_value=key_value)
|
|
return render(request, "payments/failed.html")
|
|
|
|
# -> Conversion Razorpay Payment Done Message
|
|
|
|
|
|
def paymentDoneppt_RazorPay(request):
|
|
keyID = request.session["keyID"]
|
|
keySecret = request.session["keySecret"]
|
|
if request.method == "POST":
|
|
# x = pptconversion.objects.get(ppt_string=request.session["pptstring"])
|
|
# if request.session.get("want_to_be_vetted") == "on":
|
|
# total_amount = x.amount
|
|
# else:
|
|
# total_amount = x.amount
|
|
# razorpay_order_id = request.POST["razorpay_order_id"]
|
|
# razorpay_payment_id = request.POST["razorpay_payment_id"]
|
|
# razorpay_signature = request.POST["razorpay_signature"]
|
|
# client = razorpay.Client(auth=(keyID, keySecret))
|
|
# params_dict = {
|
|
# "razorpay_order_id": razorpay_order_id,
|
|
# "razorpay_payment_id": razorpay_payment_id,
|
|
# "razorpay_signature": razorpay_signature,
|
|
# }
|
|
# try:
|
|
# client.utility.verify_payment_signature(params_dict)
|
|
# except:
|
|
# x.delete()
|
|
# subject = "Something really went wrong"
|
|
# from_email = settings.EMAIL_HOST_USER
|
|
# to = request.user.email
|
|
# context_2 = {
|
|
# "Name": request.user.email,
|
|
# "service_name": "Conversion",
|
|
# }
|
|
# mnfnsendemail(
|
|
# to, subject, "payment/templates/payments/MR24.html", context_2, from_email)
|
|
# return render(request, "payments/failed.html")
|
|
#
|
|
# if request.session["pay_with_wallet"] == "yes":
|
|
# deduction_for_sep_wall(request)
|
|
# wall = Wallet.objects.get(user=request.user)
|
|
# wall.balance = request.session["fbalance"]
|
|
# wall.save()
|
|
#
|
|
# # payFetch = client.payment.fetch(razorpay_payment_id,({'expand[]':'card'}))
|
|
# if client.payment.fetch(razorpay_payment_id, {"expand[]": "card"}):
|
|
# pay_method = "CARD"
|
|
# else:
|
|
# pay_method = "NOTCard"
|
|
# # -----------Adding Details to payment Details--------------------------
|
|
# currencyrate = request.session["CurrencyRate"]
|
|
# user_id = request.user
|
|
# payment_id = razorpay_payment_id
|
|
# services_used = "Conversion"
|
|
# total_amounts = round(
|
|
# (x.slide_count * CONVERSION_PER_PAGE * currencyrate),
|
|
# 2,
|
|
# )
|
|
# discount = round((request.session["pptdiscount"] * currencyrate), 2)
|
|
# amount_charged = round((total_amount * currencyrate), 2)
|
|
# gateway_fee = round(
|
|
# ((RAZORPAY_PLATFORM_FEE / 100) * amount_charged), 2)
|
|
# currency = "INR"
|
|
# # pay_method = 'NOTCard'
|
|
# payment_status = "Success"
|
|
# payment_gateway = "RazorPay"
|
|
# number_of_pages = x.slide_count
|
|
# print("totalamount:", total_amounts)
|
|
# print("amountcharge:", amount_charged)
|
|
# print("discount:", discount)
|
|
# PaymentData.objects.create(
|
|
# user_id=user_id,
|
|
# payment_id=payment_id,
|
|
# total_amount=total_amounts,
|
|
# services_used=services_used,
|
|
# discount=discount,
|
|
# amount_charged=amount_charged,
|
|
# gateway_fee=gateway_fee,
|
|
# currency=currency,
|
|
# number_of_pages=number_of_pages,
|
|
# pay_method=pay_method,
|
|
# payment_status=payment_status,
|
|
# payment_gateway=payment_gateway,
|
|
# )
|
|
#
|
|
# with open(rf"{basePath}/ideamall/templates/ideamall/body.txt") as f:
|
|
# body = f.read()
|
|
#
|
|
# context_email = {
|
|
# "Date": date.today(),
|
|
# "Name": x.user_id.email,
|
|
# "emailcode": "",
|
|
# "heading1": "Thank you!",
|
|
# "heading2": " for using ppt conversion service "
|
|
# + " you will get notification whenever the conversation completes",
|
|
# "body": body,
|
|
# }
|
|
# # whomtosend, titleofmail, dateofemail, context\
|
|
# sendemail(
|
|
# x.user_id.email,
|
|
# "Thankyou for using service",
|
|
# date.today(),
|
|
# context_email,
|
|
# EMAIL_HOST_USER,
|
|
# ).start()
|
|
# # sdsdsadsadsdsadsadsdsdasdsaaaaaaassss
|
|
callback_context = callback(request.POST, request)
|
|
ppt_id = request.session["ppt_id"]
|
|
if callback_context['payment_status'] != 'success':
|
|
|
|
pptconversion.objects.get(ppt_id=ppt_id).delete()
|
|
subject = "Something really went wrong"
|
|
from_email = settings.EMAIL_HOST_USER
|
|
to = request.user.email
|
|
context_2 = {
|
|
"Name": request.user.email,
|
|
"service_name": "Conversion",
|
|
}
|
|
mnfnsendemail(
|
|
to, subject, "payment/templates/payments/MR24.html", context_2, from_email)
|
|
# sendmail(to_email=[ppt_instance.user_id.email,email_code='CP5')
|
|
return render(request, "payments/failed.html")
|
|
else:
|
|
total_amount = request.session["amount"]
|
|
if request.session["pay_with_wallet"] == "yes":
|
|
# deduction_for_sep_wall(request)
|
|
wall = Wallet.objects.get(user=request.user)
|
|
# for key, value in request.session.items():
|
|
# print('{} => {}'.format(key, value))
|
|
print("----------------amount", request.session["pay_wallet_deduction"])
|
|
print("----------------rate", request.session["CurrencyRate"])
|
|
print("final balance", round(wall.balance, 2) - (round(request.session["pay_wallet_deduction"], 2)))
|
|
wall.balance = round(wall.balance, 2) - (round(request.session["pay_wallet_deduction"], 2))
|
|
wall.save()
|
|
ppt_instance = pptconversion.objects.get(ppt_id=ppt_id)
|
|
# save central payment details in your database
|
|
ppt_instance.central_payment_id = request.session["central_payment_id"]
|
|
ppt_instance.payment_order_id = request.session["payment_order_id"]
|
|
ppt_instance.save()
|
|
sendmail(to_email=[ppt_instance.user_id.email], email_code='CP4')
|
|
sendmail(to_email=[ppt_instance.user_id.email], email_code='CP10')
|
|
ppt_conversion(ppt_id, request).start()
|
|
sendmail(to_email=[ppt_instance.user_id.email], email_code='CP9')
|
|
print('line---(2161)')
|
|
print('is the email working for ppt')
|
|
print('ppt_instance.user_id.email', ppt_instance.user_id.email)
|
|
del request.session["pptstring"]
|
|
return render(request, "conversion/thanksppt.html")
|
|
|
|
|
|
# -> Conversion Stripe Payment Done Message
|
|
def paymentDoneppt_stripe(request):
|
|
|
|
if request.method == "GET":
|
|
ppt_id = request.session["ppt_id"]
|
|
# x = pptconversion.objects.filter(
|
|
# ppt_string=request.session["pptstring"])
|
|
#
|
|
# total_amount = x.amount
|
|
# payment_intent_id = request.session["payment_intent_id"]
|
|
# try:
|
|
# pi = stripe.PaymentIntent.retrieve(payment_intent_id)
|
|
# except:
|
|
# x.delete()
|
|
# subject = "Something really went wrong"
|
|
# from_email = settings.EMAIL_HOST_USER
|
|
# to = request.user.email
|
|
# context_2 = {
|
|
# "Name": request.user.email,
|
|
# "service_name": "Conversion",
|
|
# }
|
|
# mnfnsendemail(
|
|
# to, subject, "payment/templates/payments/MR24.html", context_2, from_email)
|
|
# return render(request, "payments/failed.html")
|
|
#
|
|
# if pi.status == "succeeded":
|
|
#
|
|
# if request.session["pay_with_wallet"] == "yes":
|
|
# deduction_for_sep_wall(request)
|
|
# wall = Wallet.objects.get(user=request.user)
|
|
# wall.balance = request.session["fbalance"]
|
|
# wall.save()
|
|
#
|
|
# # -----------Adding Details to payment Details--------------------------
|
|
# currencyrate = request.session["CurrencyRate"]
|
|
# user_id = request.user
|
|
# payment_id = payment_intent_id
|
|
# services_used = "Conversion"
|
|
# number_of_pages = x.slide_count
|
|
# total_amounts = round(
|
|
# (x.slide_count * CONVERSION_PER_PAGE * currencyrate),
|
|
# 2,
|
|
# )
|
|
# discount = round(
|
|
# (request.session["pptdiscount"] * currencyrate), 2)
|
|
# amount_charged = round((total_amount * currencyrate), 2)
|
|
# gateway_fee = round(
|
|
# ((STRIPE_PLATFORM_FEE / 100) * amount_charged), 2)
|
|
# currency = "INR"
|
|
# pay_method = "Card"
|
|
# payment_status = "Success"
|
|
# payment_gateway = "Stripe"
|
|
# PaymentData.objects.create(
|
|
# user_id=user_id,
|
|
# services_used=services_used,
|
|
# payment_id=payment_id,
|
|
# amount_charged=amount_charged,
|
|
# total_amount=total_amounts,
|
|
# number_of_pages=number_of_pages,
|
|
# gateway_fee=gateway_fee,
|
|
# discount=discount,
|
|
# currency=currency,
|
|
# pay_method=pay_method,
|
|
# payment_status=payment_status,
|
|
# payment_gateway=payment_gateway,
|
|
# )
|
|
#
|
|
# with open(rf"{basePath}/ideamall/templates/ideamall/body.txt") as f:
|
|
# body = f.read()
|
|
#
|
|
# context_email = {
|
|
# "Date": date.today(),
|
|
# "Name": x.user_id.email,
|
|
# "emailcode": "",
|
|
# "heading1": "Thank you!",
|
|
# "heading2": " for using ppt conversion service "
|
|
# + " you will get notification whenever the conversation completes",
|
|
# "body": body,
|
|
# }
|
|
# # whomtosend, titleofmail, dateofemail, context\
|
|
# sendemail(
|
|
# x.user_id.email,
|
|
# "Thankyou for using service",
|
|
# date.today(),
|
|
# context_email,
|
|
# EMAIL_HOST_USER,
|
|
# ).start()
|
|
# # sdsdsadsadsdsadsadsdsdasdsaaaaaaassss
|
|
# ppt_conversion(x.ppt_id, request).start()
|
|
# return render(request, "conversion/thanksppt.html")
|
|
# else:
|
|
# x.delete()
|
|
# subject = "Something really went wrong"
|
|
# from_email = settings.EMAIL_HOST_USER
|
|
# to = request.user.email
|
|
# context_2 = {
|
|
# "Name": request.user.email,
|
|
# "service_name": "Conversion",
|
|
# }
|
|
# mnfnsendemail(
|
|
# to, subject, "payment/templates/payments/MR24.html", context_2, from_email)
|
|
# return render(request, "payments/failed.html")
|
|
|
|
response = {
|
|
"id": request.GET.get("payment_intent"),
|
|
"client_secret": request.GET.get("payment_intent_client_secret"),
|
|
"status": request.GET.get("redirect_status"),
|
|
}
|
|
callback_content = callback(response, request)
|
|
if callback_content['payment_status'] == "success":
|
|
if request.session["pay_with_wallet"] == "yes":
|
|
# deduction_for_sep_wall(request)
|
|
wall = Wallet.objects.get(user=request.user)
|
|
# for key, value in request.session.items():
|
|
# print('{} => {}'.format(key, value))
|
|
print("----------------amount", request.session["pay_wallet_deduction"])
|
|
print("----------------rate", request.session["CurrencyRate"])
|
|
print("final balance", round(wall.balance, 2) - (
|
|
round(request.session["pay_wallet_deduction"], 2)))
|
|
wall.balance = round(wall.balance, 2) - (
|
|
round(request.session["pay_wallet_deduction"], 2))
|
|
wall.save()
|
|
ppt_instance = pptconversion.objects.get(ppt_id=ppt_id)
|
|
ppt_instance.central_payment_id = request.session[
|
|
"central_payment_id"] # save central payment details in your database
|
|
ppt_instance.payment_order_id = request.session["payment_order_id"]
|
|
ppt_instance.save()
|
|
sendmail(to_email=[ppt_instance.user_id.email], email_code='CP4')
|
|
sendmail(to_email=[ppt_instance.user_id.email], email_code='CP10')
|
|
ppt_conversion(ppt_id, request).start()
|
|
sendmail(to_email=[ppt_instance.user_id.email], email_code='CP9')
|
|
print('line---(2282)')
|
|
print('is the email working for ppt')
|
|
del request.session["pptstring"]
|
|
return render(request, "conversion/thanksppt.html")
|
|
else:
|
|
sendmail(to_email=[ppt_instance.user_id.email], email_code='CP')
|
|
pptconversion.objects.get(ppt_id=ppt_id).delete()
|
|
subject = "Something really went wrong"
|
|
from_email = settings.EMAIL_HOST_USER
|
|
to = request.user.email
|
|
context_2 = {
|
|
"Name": request.user.email,
|
|
"service_name": "Conversion",
|
|
}
|
|
mnfnsendemail(
|
|
to, subject, "payment/templates/payments/MR24.html", context_2, from_email)
|
|
|
|
return render(request, "payments/failed.html")
|
|
|
|
|
|
# -> Actually Running Translation of book
|
|
def my_book(request):
|
|
print("Entering My_Book Conversion Function")
|
|
|
|
# -> PArsing the file location from database
|
|
y = BookConversion.objects.get(book_id=str(request.GET["book_id"]))
|
|
|
|
# -> Creating the directory for storing the extracted contents of docx
|
|
path = str(y.upload_book)
|
|
folder_name = (((path.split("/"))[-1]).split("."))[0]
|
|
|
|
if not os.path.exists(f"{basePath}/media/scripts/book/{folder_name}"):
|
|
os.mkdir(f"{basePath}/media/scripts/book/{folder_name}", mode=0o777)
|
|
|
|
# -> Creating the convert a book instance
|
|
convertBook_instance = ConvertBook()
|
|
|
|
# -> Alerting User that transaltion has started
|
|
to = request.user.email
|
|
key_value = {
|
|
"User": request.user.username,
|
|
}
|
|
sendmail(to_email=[to], email_code="PP22", key_value=key_value)
|
|
|
|
# -> Extracting the Docx contents as XML
|
|
data_docx_list = convertBook_instance.extract_docx_contents(
|
|
basePath + "/media/" + str(y.upload_book), f"{basePath}/media/scripts/book/{folder_name}")
|
|
|
|
print("I am done till here 7878", data_docx_list)
|
|
|
|
# -> Translating the contents and Recreating the docx book using the translated text
|
|
convertBook_instance.recreate_translated_book(
|
|
data_docx_list, f"{basePath}/media/scripts/book/{folder_name}/{str(folder_name)}_translated.docx", y.source_language, y.target_language)
|
|
|
|
# orig_path = ""
|
|
# for i in range(len(path)):
|
|
# if i == len(path) - 1:
|
|
# orig_path = orig_path + str(path[i])
|
|
# else:
|
|
# orig_path = orig_path + str(path[i]) + "/"
|
|
y.translated_book_docx = f"/media/scripts/book/{folder_name}/{str(folder_name)}_translated.docx"
|
|
convert_to_pdf(f"{basePath}/media/scripts/book/{folder_name}/{str(folder_name)}_translated.docx",
|
|
rf"{basePath}/media/scripts/book/{folder_name}/")
|
|
y.translated_book_pdf = rf"/media/scripts/book/{folder_name}/{str(folder_name)}_translated.pdf"
|
|
translated_book_pdf = rf"/media/scripts/book/{folder_name}/{str(folder_name)}_translated.pdf"
|
|
y.save()
|
|
|
|
# bookconversion = {}
|
|
# if UserCredentialsForBlockchain.objects.filter(user=request.user).exists():
|
|
# contex =request.session["original_book"]
|
|
# hash = uploadDataToIPFSNode(contex)
|
|
# print("my_hash1",hash)
|
|
# bookconversion["original_bookFile_hash"] = hash
|
|
|
|
# if UserCredentialsForBlockchain.objects.filter(user=request.user).exists():
|
|
# contex =translated_book_pdf
|
|
# hash = uploadDataToIPFSNode(contex)
|
|
# print("my_hash2",hash)
|
|
# bookconversion["translated_bookFile_hash"] = hash
|
|
|
|
# if UserCredentialsForBlockchain.objects.filter(user=request.user).exists():
|
|
# blockchain_obj = UserCredentialsForBlockchain.objects.get(user=request.user)
|
|
# UserId = blockchain_obj.user_id
|
|
# Project = script_id
|
|
# Data = str(bookconversion)
|
|
# userPrivateKey =blockchain_obj.privateKey
|
|
# userkey =decryptionOfPrivate(userPrivateKey)
|
|
# hash =UploadConversionData(userkey.decode('utf-8'),UserId,Project,Data)
|
|
|
|
to = request.user.email
|
|
key_value = {
|
|
"User": request.user.username,
|
|
}
|
|
sendmail(to_email=[to], email_code="PP23", key_value=key_value)
|
|
|
|
print("Exiting My_Book Conversion Function")
|
|
return JsonResponse({"status": "success"}, status=200)
|
|
|
|
|
|
def book_payment(request):
|
|
# new payment 8000
|
|
set_payment_token(request)
|
|
keyID = request.session["keyID"]
|
|
keySecret = request.session["keySecret"]
|
|
if request.method == "POST":
|
|
if request.POST.get("want_to_be_vetted") == "yes":
|
|
# print("amount to be paid", request.session["amount"])
|
|
# total_amount = request.session["amount"]
|
|
# amount_lpp_without_discount = request.session["onlylppfee"]
|
|
# print(request.session["amount"], " : Final Amount")
|
|
request.session["want_to_be_vetted"] = "on"
|
|
else:
|
|
# print("amount to be paid", request.session["amount"])
|
|
# total_amount = request.session["amount"]
|
|
request.session["want_to_be_vetted"] = request.POST.get(
|
|
"want_to_be_vetted")
|
|
# print("amount to be paid", request.session["amount"])
|
|
total_amount = request.session["amount"]
|
|
# request.session["want_to_be_vetted"] = request.POST.get(
|
|
# "want_to_be_vetted")
|
|
# request.session["interested_to_be_lpp"] = request.POST.get(
|
|
# "interested_to_be_lpp"
|
|
# )
|
|
request.session["amount_before_pay_wallet"] = total_amount
|
|
request.session["pay_with_wallet"] = "no"
|
|
try:
|
|
if request.POST.get("pay_wallet") == "on":
|
|
request.session["pay_with_wallet"] = "yes"
|
|
with open(f"{basePath}/MNF/json_keys/conversionRates.json") as c:
|
|
curr = json.load(c)
|
|
print(curr["rates"]["INR"])
|
|
try:
|
|
rate = curr["rates"]["INR"]
|
|
except Exception as e:
|
|
print("checkout error", e)
|
|
rate = 80
|
|
# balance = float(request.POST["balance"])
|
|
# payable = float(request.POST["payable"])
|
|
# wall = Wallet.objects.get(user=request.user)
|
|
# request.session["fbalance"] = float(
|
|
# wall.balance) - float(balance * rate)
|
|
# wall.save()
|
|
# request.session["amount"] = payable
|
|
# total_amount = request.session["amount"]
|
|
print("Checking Wallet")
|
|
wall = Wallet.objects.get(user=request.user)
|
|
print("this is walet", wall.balance)
|
|
print(wall.balance)
|
|
if wall.balance >= (total_amount * rate):
|
|
print("wallet if hai")
|
|
request.session["pay_wallet_deduction"] = round(total_amount * rate, 2)
|
|
total_amount = 0
|
|
else:
|
|
print("wallet else hai")
|
|
request.session["pay_wallet_deduction"] = round(wall.balance, 2)
|
|
total_amount = round((round(total_amount * rate, 2) - round(wall.balance, 2)) / rate, 2)
|
|
|
|
except Exception as e:
|
|
print("Error is ",e)
|
|
# total_amount = request.session["amount"]
|
|
total_amount1 = request.session["subtotal"]
|
|
# amount_charged = request.session["amount"]
|
|
# amount_discount = request.session["discount"]
|
|
# total_amount1 = request.session["subtotal"]
|
|
# amount_charged = request.session["amount"]
|
|
amount_discount = request.session["discount"]
|
|
|
|
services_used = 2 if request.POST.get("want_to_be_vetted") == "yes" else 1
|
|
context = create_indent(request, 'Conversion', str(request.session["book_id"]), services_used, '',
|
|
total_amount1, total_amount, amount_discount)
|
|
print("Create indent 9987", context)
|
|
for key, value in request.session.items():
|
|
print('{} => {}'.format(key, value))
|
|
print(str(request.session["book_id"]))
|
|
# instance = MNFScriptDatabase.objects.get(script_id=str(request.session["script_id"]))
|
|
with open(f"{basePath}/MNF/json_keys/conversionRates.json") as c:
|
|
curr = json.load(c)
|
|
try:
|
|
rate = curr["rates"]["INR"]
|
|
except Exception as e:
|
|
rate = 80
|
|
|
|
request.session["CurrencyRate"] = rate
|
|
centralPayment_instance = CentralPayment.objects.get(
|
|
id=context["central_pay_id"])
|
|
|
|
# handle razor pay gateway →
|
|
if "orderId" in context:
|
|
# instance.payment_order_id = context["orderId"]
|
|
# instance.central_payment_id = context["central_pay_id"]
|
|
# instance.save() # save central payment details in your database
|
|
request.session["payment_order_id"] = context["orderId"]
|
|
request.session["central_payment_id"] = context["central_pay_id"]
|
|
|
|
pid = centralPayment_instance.order_id
|
|
amtINR = round(centralPayment_instance.amount_charged * rate, 2)
|
|
|
|
context = {
|
|
"pk": keyID,
|
|
"amtINR": amtINR,
|
|
"pid": pid,
|
|
"amount": round(centralPayment_instance.amount_charged,2),
|
|
}
|
|
return render(request, "conversion/checkoutBook_RazorPay.html", context)
|
|
|
|
# handle stripe gateway →
|
|
elif "client_secret" in context:
|
|
# save central payment details in your database
|
|
request.session["payment_order_id"] = context["client_secret"]
|
|
request.session["central_payment_id"] = context["central_pay_id"]
|
|
|
|
amtINR = round(centralPayment_instance.amount_charged * rate,2)
|
|
context = {
|
|
"pk": STRIPE_PUB_KEY,
|
|
"total_amount": round(centralPayment_instance.amount_charged, 2),
|
|
"secret_key": context["client_secret"],
|
|
"amtINR": amtINR,
|
|
"STRIPE_PUBLISHABLE_KEY": STRIPE_PUB_KEY,
|
|
|
|
}
|
|
return render(request, "conversion/checkoutBook_Stripe.html", context)
|
|
|
|
# handle corporate profile →
|
|
elif "monthly_user" in context:
|
|
book_instance = BookConversion.objects.get(
|
|
book_id=request.session["book_id"])
|
|
book_instance.central_payment_id = context["central_pay_id"]
|
|
book_instance.payment_order_id = "monthly_user"
|
|
book_instance.save()
|
|
# instance.payment_order_id = "corporate profile"
|
|
# instance.central_payment_id = "corporate profile"
|
|
# instance.save()
|
|
|
|
return render(request, "conversion/thanksbook.html", {"book_id": request.session["book_id"]})
|
|
|
|
|
|
# -> At 10sec intervals check if book conversion completed
|
|
def is_book_converted(request):
|
|
book_id = request.GET["book_id"]
|
|
obj = StoryConversion.objects.get(story_id=book_id)
|
|
print("book still converting", obj.translated_book_docx)
|
|
if obj.translated_book_docx:
|
|
return JsonResponse({"status": "success"}, status=200)
|
|
else:
|
|
return JsonResponse({"status": "pending"}, status=202)
|
|
|
|
|
|
# -> Fetching the Source Language and Number of Pages of book
|
|
def check_book_lang(request):
|
|
y = BookConversion()
|
|
y.user_id = request.user
|
|
now = datetime.datetime.now()
|
|
rightNow = str(now)
|
|
dash_splited = rightNow.split("-")
|
|
str1 = ""
|
|
for i in dash_splited:
|
|
str1 += str(i)
|
|
dash_splited1 = str1.split(" ")
|
|
str2 = ""
|
|
for i in dash_splited1:
|
|
str2 += str(i)
|
|
dash_splited2 = str2.split(":")
|
|
str3 = ""
|
|
for i in dash_splited2:
|
|
str3 += str(i)
|
|
dash_splited3 = str3.split(".")
|
|
str4 = dash_splited3[0]
|
|
|
|
# -> Checking Book Source Language
|
|
y.book_id = "book_" + str(str4)
|
|
y.upload_book = request.FILES['my_book']
|
|
|
|
# request.session["original_book"] = request.FILES['my_book']
|
|
y.save()
|
|
|
|
try:
|
|
number_pages = countPages(
|
|
str(BASE_DIR) + "/media/" +
|
|
str(y.upload_book), str(y.upload_book)[13:-4] + "pdf"
|
|
)
|
|
docxx = docx.Document(str(BASE_DIR) + "/media/" +
|
|
str(y.upload_book))
|
|
text = ""
|
|
for paragraph in docxx.paragraphs:
|
|
text += paragraph.text
|
|
if text.strip() == "" or text.strip() == " " or len(text.strip()) < 5:
|
|
pass
|
|
else:
|
|
break
|
|
print("text is",text)
|
|
src_language = language_detector(text)
|
|
BookConversion.objects.get(id=y.id).delete()
|
|
return JsonResponse({"Detected Language": languages[src_language], "number_pages": number_pages})
|
|
except Exception as e:
|
|
print("Exception for language not getting detected is:", e)
|
|
BookConversion.objects.get(id=y.id).delete()
|
|
return JsonResponse({}, status=505)
|
|
|
|
|
|
# -> Initital Saving of Book in database and extracting various languages present in that
|
|
def convert_book(request):
|
|
print("Request i", request.method)
|
|
if request.method == "POST":
|
|
print("Yes i am in here")
|
|
y = BookConversion()
|
|
y.user_id = request.user
|
|
now = datetime.datetime.now()
|
|
rightNow = str(now)
|
|
dash_splited = rightNow.split("-")
|
|
str1 = ""
|
|
for i in dash_splited:
|
|
str1 += str(i)
|
|
dash_splited1 = str1.split(" ")
|
|
str2 = ""
|
|
for i in dash_splited1:
|
|
str2 += str(i)
|
|
dash_splited2 = str2.split(":")
|
|
str3 = ""
|
|
for i in dash_splited2:
|
|
str3 += str(i)
|
|
dash_splited3 = str3.split(".")
|
|
str4 = dash_splited3[0]
|
|
|
|
y.book_id = "book_" + str(str4)
|
|
if request.POST.get("book_id"):
|
|
print("Inside sample book if case")
|
|
# book_sample = SampleBook.objects.get(book_id=request.POST.get("book_id"))
|
|
# y.upload_book = book_sample.book_path
|
|
# # print(request.POST.get("header_footer_addition"), "<- checkbox value")
|
|
# # y.source_language = src_language
|
|
# y.numPages = book_sample.number_pages
|
|
# y.source_language = ((list(languages.keys()))[list(
|
|
# languages.values()).index(book_sample.source_lang)])
|
|
# y.target_language = ((list(languages.keys()))[list(
|
|
# languages.values()).index(request.POST.get("target_lang"))])
|
|
# y.header_footer_present = True if request.POST.get(
|
|
# "header_footer_addition") else False
|
|
# y.save()
|
|
else:
|
|
|
|
Book = AScript(request.POST, request.FILES)
|
|
if Book.is_valid():
|
|
y.upload_book = Book.cleaned_data.get("myfile")
|
|
# print(request.POST.get("header_footer_addition"), "<- checkbox value")
|
|
# y.source_language = src_language
|
|
y.numPages = request.POST.get("number_pages_var")
|
|
y.source_language = ((list(languages.keys()))[list(
|
|
languages.values()).index(request.POST.get("src_lang"))])
|
|
y.target_language = ((list(languages.keys()))[list(
|
|
languages.values()).index(request.POST.get("target_lang"))])
|
|
y.header_footer_present = True if request.POST.get(
|
|
"header_footer_addition") else False
|
|
y.save()
|
|
|
|
if int(y.numPages) <= 5 or request.POST.get("book_id"):
|
|
return render(request, "conversion/thanksbook.html", {"book_id": y.book_id})
|
|
|
|
else:
|
|
context = {}
|
|
if request.POST.get("sample_free") == "on":
|
|
return render(request, "conversion/thanksbook.html", {"book_id": y.book_id, "restrict_to_five":"yes"})
|
|
numPages = int(y.numPages)
|
|
|
|
if request.POST.get("to_be_vetted_by_lpp") == "on":
|
|
lpp_available = "yes"
|
|
total_amount = round(int(float(pricing_data('Book Conversion', 4))) * numPages, 2)
|
|
|
|
else:
|
|
lpp_available = "no"
|
|
total_amount = round(int(float(pricing_data('Script Conversion', 2))) * numPages, 2)
|
|
|
|
context["subtotal"] = round(total_amount, 2)
|
|
context["early_bird_discount"] = discount_limit_handler(DISCOUNT["early_bird"])
|
|
context["early_bird_calculate"] = round(
|
|
float((total_amount) * context["early_bird_discount"] / 100), 2)
|
|
|
|
# staff discount
|
|
if User.objects.get(id=request.user.id).is_staff: # changes done by manoj
|
|
context["sdiscount"] = discount_limit_handler(DISCOUNT["employ_discount"])
|
|
context["staff_discount_calculate"] = round(float(
|
|
(total_amount - context["early_bird_calculate"]) * context[
|
|
"sdiscount"] / 100), 2)
|
|
else:
|
|
context["sdiscount"] = 0
|
|
context["staff_discount_calculate"] = 0
|
|
|
|
user = User.objects.get(id=request.user.id)
|
|
|
|
try:
|
|
memberType = privilegedUser1.objects.filter(user=user, is_active="yes")
|
|
if memberType:
|
|
memberType = memberType.first().memberType
|
|
|
|
if memberType == "normal":
|
|
context["pdiscount"] = 0
|
|
context["membership_discount_calculate"] = 0
|
|
|
|
elif memberType == "yearly":
|
|
context["pdiscount"] = discount_limit_handler(DISCOUNT["yearly_member_additional"])
|
|
context["membership_discount_calculate"] = round(float((
|
|
total_amount -
|
|
context[
|
|
"early_bird_calculate"] -
|
|
context[
|
|
"staff_discount_calculate"]) *
|
|
context["pdiscount"] / 100), 2)
|
|
|
|
elif memberType == "Life Member":
|
|
context["pdiscount"] = discount_limit_handler(DISCOUNT["life_member_additional"])
|
|
context["membership_discount_calculate"] = round(float((
|
|
total_amount -
|
|
context[
|
|
"early_bird_calculate"] -
|
|
context[
|
|
"staff_discount_calculate"]) *
|
|
context["pdiscount"] / 100), 2)
|
|
if not privilegedUser1.objects.filter(user=request.user, is_active="yes").exists():
|
|
context["monthly_membership"] = 1
|
|
# context["membershipNarration"] = discount_limit_handler(DISCOUNT["monthly_member"])
|
|
context["pdiscount"] = 0
|
|
context["membership_discount_calculate"] = 0
|
|
except:
|
|
context["monthly_membership"] = 1
|
|
context["pdiscount"] = 0
|
|
context["membership_discount_calculate"] = 0
|
|
|
|
get_student_discount = get_discount(request.user.id, total_amount)
|
|
if get_student_discount == 0:
|
|
context["student_discount"] = 0
|
|
context["student_discount_calculate"] = 0
|
|
else:
|
|
context["student_discount"] = get_student_discount
|
|
context["student_discount_calculate"] = round(float((total_amount -
|
|
context["early_bird_calculate"] -
|
|
context["staff_discount_calculate"] -
|
|
context["membership_discount_calculate"]) *
|
|
context["student_discount"] / 100), 2)
|
|
|
|
context["Total_discount"] = round(float(
|
|
context["early_bird_calculate"] + context["staff_discount_calculate"] +
|
|
context["membership_discount_calculate"] + context["student_discount_calculate"]), 2)
|
|
context["remaining_amount"] = round(float(total_amount - context["Total_discount"]), 2)
|
|
context["net_service_charge"] = round(
|
|
float(context["remaining_amount"]), 2)
|
|
# GST
|
|
context["gst"] = discount_limit_handler(DISCOUNT["gst"])
|
|
context["gst_calculate"] = round(float(context["remaining_amount"] * context["gst"] / 100), 2)
|
|
context["net_payable"] = round(float(context["remaining_amount"] + context["gst_calculate"]), 2)
|
|
print(context)
|
|
|
|
|
|
# -> OLD Code
|
|
|
|
# context["book_id"] = y.book_id
|
|
# request.session["book_id"] = y.book_id
|
|
# payment calculation for book
|
|
# pdiscount = 1
|
|
# sdiscount = 1
|
|
# mdiscount = 1 - settings.RUNNING_DISCOUNT_CONVERSION / 100
|
|
# # numPages = int(numPages)
|
|
#
|
|
# if not privilegedUser1.objects.filter(
|
|
# user=request.user, is_active="yes"
|
|
# ).exists():
|
|
# # messages.success(request, "Become privileged member")
|
|
# # return redirect("payment")
|
|
# request.session["directly_pay_monthly"] = 1
|
|
# context = {"directly_pay_monthly": 1}
|
|
# try:
|
|
# memberType = privilegedUser1.objects.get(
|
|
# user=request.user, is_active="yes"
|
|
# ).memberType
|
|
# if memberType:
|
|
# if memberType == "normal":
|
|
# pdiscount = 1
|
|
# context["pdiscount"] = 0
|
|
# elif memberType == "yearly":
|
|
# pdiscount = 1 - settings.YEARLY_MEMBER_ADDITIONAL / 100
|
|
# context["pdiscount"] = settings.YEARLY_MEMBER_ADDITIONAL
|
|
# elif memberType == "Life Member":
|
|
# pdiscount = 1 - settings.LIFE_MEMBER_ADDITIONAL / 100
|
|
# context["pdiscount"] = settings.LIFE_MEMBER_ADDITIONAL
|
|
# if User.objects.get(id=request.user.id).is_staff:
|
|
# sdiscount = 1 - settings.EMPLOY_DISCOUNT / 100
|
|
# except:
|
|
# pdiscount = 1
|
|
# sdiscount = 1
|
|
# context["pdiscount"] = 0
|
|
# # pdiscount = 1
|
|
# # sdiscount = 1
|
|
# # mdiscount = 1 - settings.RUNNING_DISCOUNT_CONVERSION / 100
|
|
# # memberType = privilegedUser1.objects.get(
|
|
# # user=request.user, is_active="yes"
|
|
# # ).memberType
|
|
# # if memberType:
|
|
# # if memberType == "normal":
|
|
# # pdiscount = 1
|
|
# # context["pdiscount"] = 0
|
|
# # elif memberType == "yearly":
|
|
# # pdiscount = 1 - settings.YEARLY_MEMBER_ADDITIONAL / 100
|
|
# # context["pdiscount"] = settings.YEARLY_MEMBER_ADDITIONAL
|
|
# # elif memberType == "Life Member":
|
|
# # pdiscount = 1 - settings.LIFE_MEMBER_ADDITIONAL / 100
|
|
# # context["pdiscount"] = settings.LIFE_MEMBER_ADDITIONAL
|
|
# if User.objects.get(id=request.user.id).is_staff:
|
|
# sdiscount = 1 - settings.EMPLOY_DISCOUNT / 100
|
|
# # if request.POST.get("to_be_vetted_by_lpp") == "on":
|
|
# # lpp_available = "yes"
|
|
# # try:
|
|
# # lppamt = (
|
|
# # (numPages * settings.CONVERSION_PER_PAGE)
|
|
# # + (numPages * settings.LPP_PER_PAGE)
|
|
# # + context["directly_pay_monthly"]
|
|
# # )
|
|
# # except:
|
|
# # lppamt = (numPages * settings.CONVERSION_PER_PAGE) + (
|
|
# # numPages * settings.LPP_PER_PAGE
|
|
# # )
|
|
# # context["subtotal"] = round(
|
|
# # numPages * settings.CONVERSION_PER_PAGE, 2
|
|
# # )
|
|
# # # amt = numPages * settings.CONVERSION_PER_PAGE
|
|
# # # context["subtotal"] = round(amt, 2)
|
|
# #
|
|
# # # lppamt = (numPages * settings.CONVERSION_PER_PAGE) + (
|
|
# # # numPages * settings.LPP_PER_PAGE
|
|
# # # )
|
|
# # context["onlylppfee"] = round((numPages * settings.LPP_PER_PAGE), 2)
|
|
# # context["sublpptotal"] = round(lppamt, 2)
|
|
# # context["amount"] = round(
|
|
# # mdiscount * lppamt * pdiscount * sdiscount, 2
|
|
# # )
|
|
# # context["discount"] = lppamt - context["amount"]
|
|
# # request.session["amount"] = context["amount"]
|
|
# # request.session["onlylppfee"] = context["onlylppfee"]
|
|
# # request.session["lppamount"] = context["amount"]
|
|
# # request.session["discount"] = context["discount"]
|
|
# # request.session["member_discount"] = mdiscount
|
|
# # request.session["running_discount"] = pdiscount
|
|
# # request.session["team_discount"] = sdiscount
|
|
# # request.session["want_to_be_vetted"] = "on"
|
|
# # else:
|
|
|
|
# lpp_available = "no"
|
|
# try:
|
|
# amt = (
|
|
# numPages
|
|
# * settings.CONVERSION_PER_PAGE
|
|
# + context["directly_pay_monthly"]
|
|
# )
|
|
# except:
|
|
# amt = numPages * settings.CONVERSION_PER_PAGE
|
|
|
|
# context["subtotal"] = round(
|
|
# numPages * settings.CONVERSION_PER_PAGE, 2
|
|
# )
|
|
# context["amount"] = round(
|
|
# mdiscount * amt * pdiscount * sdiscount, 2
|
|
# )
|
|
# context["discount"] = amt - context["amount"]
|
|
#
|
|
# # try:
|
|
# request.session["amount"] = context["amount"]
|
|
# # except:
|
|
# # request.session["amount"] = context["amount"]
|
|
# request.session["subtotal"] = context["subtotal"]
|
|
# request.session["discount"] = context["discount"]
|
|
#
|
|
# context["conversion_per_page"] = settings.CONVERSION_PER_PAGE
|
|
# context["lpp_per_page"] = settings.LPP_PER_PAGE
|
|
# context[
|
|
# "running_discount_conversion"
|
|
# ] = settings.RUNNING_DISCOUNT_CONVERSION
|
|
# context["employ_discount"] = settings.EMPLOY_DISCOUNT
|
|
# context["yearly_member_additional"] = settings.YEARLY_MEMBER_ADDITIONAL
|
|
# context["life_member_additional"] = settings.LIFE_MEMBER_ADDITIONAL
|
|
# # context["restrict_to_five"] = "no"
|
|
# context["lpp_available"] = lpp_available.upper()
|
|
# context["numPages"] = numPages
|
|
# context["book_title"] = str(y.upload_book)
|
|
# request.session["book_id"] = str(y.book_id)
|
|
# context["src_lang"] = request.POST.get("src_lang")
|
|
# context["dest_lang"] = request.POST.get("target_lang")
|
|
# # request.session["script_file_path"] = x.script_file_path
|
|
|
|
context["restrict_to_five"] = "no"
|
|
context["lpp_available"] = lpp_available.upper()
|
|
context["numPages"] = numPages
|
|
context["book_title"] = str(y.upload_book)
|
|
context["src_lang"] = request.POST.get("src_lang")
|
|
context["dest_lang"] = request.POST.get("target_lang")
|
|
request.session["amount"] = context["net_payable"]
|
|
request.session["subtotal"] = context["subtotal"]
|
|
request.session["discount"] = context["Total_discount"]
|
|
request.session["book_id"] = str(y.book_id)
|
|
request.session["book_title"] = str(y.upload_book)
|
|
request.session["numPages"] = numPages
|
|
try:
|
|
wall = Wallet.objects.get(user=request.user)
|
|
context["balance"] = round(wall.balance, 2)
|
|
except:
|
|
context["balance"] = -1
|
|
with open(f"{basePath}/MNF/json_keys/conversionRates.json") as c:
|
|
curr = json.load(c)
|
|
try:
|
|
rate = curr["rates"]["INR"]
|
|
# c = CurrencyRates()
|
|
# rate = c.get_rate("USD", str(currency.upper()))
|
|
except Exception as e:
|
|
print("checkout error", e)
|
|
rate = 80
|
|
context["rate"] = rate
|
|
str1 = str(datetime.datetime.now()).split("-")
|
|
date_at = f'{str1[2][0:2]} - {str1[1]} - {str1[0]}'
|
|
context['date_at'] = date_at
|
|
try:
|
|
cd = centralDatabase.objects.get(user_id=request.user)
|
|
name = cd.firstName if cd.firstName else user.username
|
|
email_id = cd.email if cd.email else user.email
|
|
phone_number = str(cd.countryCode) + str(cd.contact) if cd.contact else "N/A"
|
|
address = cd.address if cd.address else "N/A"
|
|
except:
|
|
name = user.username
|
|
email_id = user.email
|
|
phone_number = "N/A"
|
|
address = "N/A"
|
|
|
|
context["name"] = name
|
|
context["email_id"] = email_id
|
|
context["phone_number"] = phone_number
|
|
context["address"] = address
|
|
# try:
|
|
# context["firstdiscount"] =
|
|
# context["seconddiscount"] =
|
|
# context["thirddiscount"] =
|
|
# except Exception as e:
|
|
# print(e, "<- Error")
|
|
|
|
return render(request, "conversion/invoice_book.html", context)
|
|
|
|
return render(request, "conversion/convertBook.html")
|
|
|
|
|
|
# -> For Viewing Your Books
|
|
# def view_converted_books(request):
|
|
# number = ReferUser.objects.filter(refferedBy=request.user).count()
|
|
# obj = BookConversion.objects.filter(
|
|
# user_id=request.user).order_by("-date_at")
|
|
#
|
|
# book_path = []
|
|
# pq = 0
|
|
# for i in obj:
|
|
# if i.translated_book_docx != "":
|
|
# book_path.append(i.translated_book_docx)
|
|
# pq += 1
|
|
#
|
|
# return render(
|
|
# request,
|
|
# "conversion/viewConvertedBooks.html",
|
|
# {"script_path": obj, "pq": pq, "number": number},
|
|
# )
|
|
|
|
|
|
# -> For Deleting your Book
|
|
def delete_converted_book(request, id):
|
|
to = request.user.email
|
|
key_value = {
|
|
"User": request.user.username,
|
|
"book_name": (((str(BookConversion.objects.get(id=id).upload_book).split("/"))[-1]).split("."))[0]
|
|
}
|
|
sendmail(to_email=[to], email_code="PP25", key_value=key_value)
|
|
|
|
BookConversion.objects.get(id=id).delete()
|
|
# if UserCredentialsForBlockchain.objects.filter(user=request.user).exists():
|
|
# blockchain_obj = UserCredentialsForBlockchain.objects.get(user=request.user)
|
|
# userkey =decryptionOfPrivate(blockchain_obj.privateKey)
|
|
# deleteConversion(userkey.decode('utf-8'),blockchain_obj.user_id,id)
|
|
return HttpResponseRedirect("/conversion/view_conversion")
|
|
|
|
|
|
def paymentDoneBook_RazorPay(request):
|
|
keyID = request.session["keyID"]
|
|
keySecret = request.session["keySecret"]
|
|
if request.method == "POST":
|
|
book_id = request.session["book_id"]
|
|
book_title = request.session["book_title"]
|
|
# if request.session.get("want_to_be_vetted"):
|
|
# total_amount = request.session["lppamount"]
|
|
# else:
|
|
# total_amount = request.session["amount"]
|
|
# to_be_vetted_by_lpp = request.session["want_to_be_vetted"]
|
|
# total_amount = request.session["amount"]
|
|
# razorpay_order_id = request.POST["razorpay_order_id"]
|
|
# razorpay_payment_id = request.POST["razorpay_payment_id"]
|
|
# razorpay_signature = request.POST["razorpay_signature"]
|
|
# client = razorpay.Client(auth=(keyID, keySecret))
|
|
# params_dict = {
|
|
# "razorpay_order_id": razorpay_order_id,
|
|
# "razorpay_payment_id": razorpay_payment_id,
|
|
# "razorpay_signature": razorpay_signature,
|
|
# }
|
|
|
|
callback_context = callback(request.POST, request)
|
|
if callback_context['payment_status'] != 'success':
|
|
BookConversion.objects.get(book_id=book_id).delete()
|
|
# subject = "Something really went wrong"
|
|
# from_email = settings.EMAIL_HOST_USER
|
|
# to = request.user.email
|
|
# context_2 = {
|
|
# "Name": request.user.email,
|
|
# "service_name": "Conversion",
|
|
# }
|
|
# mnfnsendemail(
|
|
# to, subject, "payment/templates/payments/MR24.html", context_2, from_email)
|
|
|
|
# -> PAyment UnSuccessfull Email
|
|
to = request.user.email
|
|
key_value = {
|
|
"User": request.user.username,
|
|
}
|
|
sendmail(to_email=[to], email_code="PP26", key_value=key_value)
|
|
|
|
return render(request, "payments/failed.html")
|
|
else:
|
|
|
|
# if request.session["pay_with_wallet"] == "yes":
|
|
# deduction_for_sep_wall(request)
|
|
# wall = Wallet.objects.get(user=request.user)
|
|
# wall.balance = request.session["fbalance"]
|
|
# wall.save()
|
|
|
|
if request.session["pay_with_wallet"] == "yes":
|
|
# deduction_for_sep_wall(request)
|
|
wall = Wallet.objects.get(user=request.user)
|
|
# for key, value in request.session.items():
|
|
# print('{} => {}'.format(key, value))
|
|
print("----------------amount", request.session["pay_wallet_deduction"])
|
|
print("----------------rate", request.session["CurrencyRate"])
|
|
print("final balance", round(wall.balance, 2) - (round(request.session["pay_wallet_deduction"], 2)))
|
|
wall.balance = round(wall.balance, 2) - (round(request.session["pay_wallet_deduction"], 2))
|
|
wall.save()
|
|
|
|
book_instance = BookConversion.objects.get(book_id=book_id)
|
|
# save central payment details in your database
|
|
book_instance.central_payment_id = request.session["central_payment_id"]
|
|
book_instance.payment_order_id = request.session["payment_order_id"]
|
|
book_instance.save()
|
|
|
|
# -> PAyment UnSuccessfull Email
|
|
to = request.user.email
|
|
key_value = {
|
|
"User": request.user.username,
|
|
}
|
|
sendmail(to_email=[to], email_code="PP24", key_value=key_value)
|
|
|
|
return render(request, "conversion/thanksbook.html", {"book_id": book_id})
|
|
|
|
# c = conversionPayment()
|
|
# c.pid = privilegedUser1.objects.get(user= request.user)
|
|
# c.script_title = script_title
|
|
# c.script_id = script_id
|
|
# c.to_be_vetted_by_lpp = to_be_vetted_by_lpp
|
|
# c.payment_intent_id = razorpay_payment_id
|
|
# c.total_amount = str(total_amount)
|
|
# c.script_file_path = script_file_path
|
|
# c.has_paid = 'yes'
|
|
# c.save()
|
|
|
|
# payFetch = client.payment.fetch(razorpay_payment_id,({'expand[]':'card'}))
|
|
# if client.payment.fetch(razorpay_payment_id, {"expand[]": "card"}):
|
|
# pay_method = "CARD"
|
|
# else:
|
|
# pay_method = "NOTCard"
|
|
# # -----------Adding Details to payment Details--------------------------
|
|
# currencyrate = request.session["CurrencyRate"]
|
|
# user_id = request.user
|
|
# payment_id = razorpay_payment_id
|
|
# services_used = "Book Conversion"
|
|
# # script_info = s
|
|
# total_amounts = round(
|
|
# (request.session["numPages"] * CONVERSION_PER_PAGE * currencyrate),
|
|
# 2,
|
|
# )
|
|
# discount = round((request.session["discount"] * currencyrate), 2)
|
|
# amount_charged = round((total_amount * currencyrate), 2)
|
|
# gateway_fee = round(
|
|
# ((RAZORPAY_PLATFORM_FEE / 100) * amount_charged), 2)
|
|
# currency = "INR"
|
|
# # pay_method = 'NOTCard'
|
|
# payment_status = "Success"
|
|
# payment_gateway = "RazorPay"
|
|
# number_of_pages = request.session["numPages"]
|
|
# PaymentData.objects.create(
|
|
# user_id=user_id,
|
|
# payment_id=payment_id,
|
|
# total_amount=total_amounts,
|
|
# services_used=services_used,
|
|
# # script_info=script_info,
|
|
# discount=discount,
|
|
# amount_charged=amount_charged,
|
|
# gateway_fee=gateway_fee,
|
|
# currency=currency,
|
|
# number_of_pages=number_of_pages,
|
|
# pay_method=pay_method,
|
|
# payment_status=payment_status,
|
|
# payment_gateway=payment_gateway,
|
|
# )
|
|
# try:
|
|
# if request.session["directly_pay_monthly"]:
|
|
# lasto = privilegedUser1.objects.last()
|
|
# privilegedUser1.objects.create(
|
|
# id=int(lasto.id) + 1,
|
|
# user=user_id,
|
|
# is_active="yes",
|
|
# transactionId=payment_id,
|
|
# memberType="normal",
|
|
# months=1
|
|
# )
|
|
# del request.session['directly_pay_monthly']
|
|
# except:
|
|
# pass
|
|
|
|
# return render(request, "conversion/thanksconversion.html", context)
|
|
|
|
|
|
def paymentDoneBook_Stripe(request):
|
|
# if pi.status == "succeeded":
|
|
#
|
|
# if request.session["pay_with_wallet"] == "yes":
|
|
# deduction_for_sep_wall(request)
|
|
# walls = Wallet.objects.get(user=request.user)
|
|
# walls.balance = request.session["fbalance"]
|
|
# walls.save()
|
|
#
|
|
# # -----------Adding Details to payment Details--------------------------
|
|
# currencyrate = request.session["CurrencyRate"]
|
|
# user_id = request.user
|
|
# payment_id = payment_intent_id
|
|
# services_used = "Book Conversion"
|
|
# # script_info = s
|
|
# number_of_pages = request.session["numPages"]
|
|
# total_amounts = round(
|
|
# (request.session["numPages"] *
|
|
# CONVERSION_PER_PAGE * currencyrate),
|
|
# 2,
|
|
# )
|
|
# discount = round((request.session["discount"] * currencyrate), 2)
|
|
# amount_charged = round((total_amount * currencyrate), 2)
|
|
# gateway_fee = round(
|
|
# ((STRIPE_PLATFORM_FEE / 100) * amount_charged), 2)
|
|
# currency = "INR"
|
|
# pay_method = "Card"
|
|
# payment_status = "Success"
|
|
# payment_gateway = "Stripe"
|
|
# PaymentData.objects.create(
|
|
# user_id=user_id,
|
|
# services_used=services_used,
|
|
# payment_id=payment_id,
|
|
# # script_info=script_info,
|
|
# amount_charged=amount_charged,
|
|
# total_amount=total_amounts,
|
|
# number_of_pages=number_of_pages,
|
|
# gateway_fee=gateway_fee,
|
|
# discount=discount,
|
|
# currency=currency,
|
|
# pay_method=pay_method,
|
|
# payment_status=payment_status,
|
|
# payment_gateway=payment_gateway,
|
|
# )
|
|
# try:
|
|
# if request.session["directly_pay_monthly"]:
|
|
# lasto = privilegedUser1.objects.last()
|
|
# privilegedUser1.objects.create(
|
|
# id=int(lasto.id) + 1,
|
|
# user=user_id,
|
|
# is_active="yes",
|
|
# transactionId=payment_id,
|
|
# memberType="normal",
|
|
# months=1
|
|
# )
|
|
# del request.session['directly_pay_monthly']
|
|
# except:
|
|
# pass
|
|
#
|
|
# return render(request, "conversion/thanksbook.html", {"book_id": book_id})
|
|
#
|
|
# # return render(request, "conversion/thanksconversion.html", context)
|
|
# else:
|
|
# subject = "Something really went wrong"
|
|
# from_email = settings.EMAIL_HOST_USER
|
|
# to = request.user.email
|
|
# context_2 = {
|
|
# "Name": request.user.email,
|
|
# "service_name": "Conversion",
|
|
# }
|
|
# mnfnsendemail(
|
|
# to, subject, "payment/templates/payments/MR24.html", context_2, from_email)
|
|
# return render(request, "payments/failed.html")
|
|
|
|
if request.method == "GET":
|
|
|
|
book_id = request.session["book_id"]
|
|
book_title = request.session["book_title"]
|
|
# if request.session.get("want_to_be_vetted"):
|
|
# total_amount = request.session["lppamount"]
|
|
# else:
|
|
# total_amount = request.session["amount"]
|
|
# total_amount = request.session["amount"]
|
|
# to_be_vetted_by_lpp = request.session["want_to_be_vetted"]
|
|
# payment_intent_id = request.session["payment_intent_id"]
|
|
# pi = stripe.PaymentIntent.retrieve(payment_intent_id)
|
|
|
|
response = {
|
|
"id": request.GET.get("payment_intent"),
|
|
"client_secret": request.GET.get("payment_intent_client_secret"),
|
|
"status": request.GET.get("redirect_status"),
|
|
}
|
|
callback_content = callback(response, request)
|
|
if callback_content['payment_status'] == "success":
|
|
# if request.session["pay_with_wallet"] == "yes":
|
|
# deduction_for_sep_wall(request)
|
|
# walls = Wallet.objects.get(user=request.user)
|
|
# walls.balance = request.session["fbalance"]
|
|
# walls.save()
|
|
|
|
if request.session["pay_with_wallet"] == "yes":
|
|
# deduction_for_sep_wall(request)
|
|
wall = Wallet.objects.get(user=request.user)
|
|
# for key, value in request.session.items():
|
|
# print('{} => {}'.format(key, value))
|
|
print("----------------amount", request.session["pay_wallet_deduction"])
|
|
print("----------------rate", request.session["CurrencyRate"])
|
|
print("final balance", round(wall.balance, 2) - (round(request.session["pay_wallet_deduction"], 2)))
|
|
wall.balance = round(wall.balance, 2) - (round(request.session["pay_wallet_deduction"], 2))
|
|
wall.save()
|
|
|
|
book_instance = BookConversion.objects.get(book_id=book_id)
|
|
book_instance.central_payment_id = request.session[
|
|
"central_payment_id"] # save central payment details in your database
|
|
book_instance.payment_order_id = request.session["payment_order_id"]
|
|
book_instance.save()
|
|
|
|
# -> PAyment Successfull Email
|
|
to = request.user.email
|
|
key_value = {
|
|
"User": request.user.username,
|
|
}
|
|
sendmail(to_email=[to], email_code="PP24", key_value=key_value)
|
|
|
|
return render(request, "conversion/thanksbook.html", {"book_id": book_id})
|
|
else:
|
|
BookConversion.objects.get(book_id=book_id).delete()
|
|
# subject = "Something really went wrong"
|
|
# from_email = settings.EMAIL_HOST_USER
|
|
# to = request.user.email
|
|
# context_2 = {
|
|
# "Name": request.user.email,
|
|
# "service_name": "Conversion",
|
|
# }
|
|
# mnfnsendemail(
|
|
# to, subject, "payment/templates/payments/MR24.html", context_2, from_email)
|
|
|
|
# -> PAyment UnSuccessfull Email
|
|
to = request.user.email
|
|
key_value = {
|
|
"User": request.user.username,
|
|
}
|
|
sendmail(to_email=[to], email_code="PP26", key_value=key_value)
|
|
|
|
return render(request, "payments/failed.html")
|
|
|
|
|
|
# #IPFS
|
|
|
|
# def start_ipfs_daemon():
|
|
# try:
|
|
# # Check if the IPFS daemon is already running
|
|
# subprocess.check_output(["ipfs", "id"])
|
|
# print("IPFS daemon is already running.")
|
|
# except subprocess.CalledProcessError:
|
|
# # If the IPFS daemon is not running, start it
|
|
# print("Starting IPFS daemon...")
|
|
# subprocess.Popen(["ipfs", "daemon"])
|
|
# # Wait for the daemon to start (you can adjust the delay as needed)
|
|
# time.sleep(5)
|
|
# print("IPFS daemon is now running.")
|
|
# #IPFS END
|
|
# start_ipfs_daemon()
|
|
|
|
|
|
# -> For making Translated PPT's
|
|
class ppt_conversion(threading.Thread):
|
|
def __init__(self, ppt, request, restrict=False):
|
|
self.ppt = ppt
|
|
self.request = request
|
|
self.restrict = restrict
|
|
threading.Thread.__init__(self)
|
|
|
|
def run(self):
|
|
try:
|
|
x = pptconversion.objects.get(ppt_id=self.ppt)
|
|
presentation = Presentation(x.upload_ppt)
|
|
if self.restrict:
|
|
presentation = Presentation(x.upload_ppt)
|
|
xml_slides = presentation.slides._sldIdLst
|
|
|
|
slides = list(xml_slides)
|
|
|
|
# Then I loop for all except the first (index 0):
|
|
|
|
for index in range(3, len(slides)):
|
|
xml_slides.remove(slides[index])
|
|
|
|
t = random.randint(1, 1000)
|
|
times = time.time()
|
|
times = int(times)
|
|
for key, value in languages.items():
|
|
if value == x.target_lang:
|
|
target = key
|
|
if value == x.source_lang:
|
|
source = key
|
|
print(">:>:>:>:12 translation start")
|
|
translate_presentation(presentation, source,
|
|
target, x.target_script, self.restrict)
|
|
print(">:>:>:>:12 translation end")
|
|
|
|
translated_ppt = f"{x.user_id}-{source}-{target}-{t}-{times}.pptx"
|
|
paths = f"{basePath}/media/ppt/converted/{translated_ppt}"
|
|
presentation.save(paths)
|
|
print(f"presentation convert saved {translated_ppt}")
|
|
x.translated_ppt = translated_ppt
|
|
x.save()
|
|
print('x.user_id.email', x.user_id.email)
|
|
sendmail(to_email=[x.user_id.email], email_code='CP2')
|
|
|
|
# Blockchain here--->
|
|
|
|
if UserCredentialsForBlockchain.objects.filter(user=self.request.user).exists():
|
|
blockchain_obj = UserCredentialsForBlockchain.objects.get(
|
|
user=self.request.user)
|
|
privatekey = blockchain_obj.privateKey
|
|
user_id = blockchain_obj.user_id
|
|
Project = self.request.session["script_id"]
|
|
private_Key = decryptionOfPrivate(privatekey)
|
|
status, getData = getPPTConversion(
|
|
private_Key.decode('utf-8'), user_id, Project)
|
|
if status == True:
|
|
data1 = getData[1]
|
|
pptconversion1 = eval(data1)
|
|
with open(f"{basePath}/media/ppt/converted/{translated_ppt}", 'rb') as _file:
|
|
hash = uploadDataToIPFSNode(_file)
|
|
pptconversion1["translated_ppt_hash"] = hash
|
|
pptconversion1["translated_ppt_path"] = paths
|
|
pptconversion1["translated_ppt"] = translated_ppt
|
|
original_file_path = pptconversion1.get("ppt_scriptFile_path")
|
|
user_id = blockchain_obj.user_id
|
|
project = self.request.session["script_id"]
|
|
Data = str(pptconversion1)
|
|
response = UploadPPTConversionData(
|
|
OWNER_KEY,blockchain_obj.publicKey,user_id, project, Data)
|
|
print("Response_final :", response)
|
|
hash = hash_decrypation(hash)
|
|
certificatepath = certificateGenrate(self.request.user.username,"PPT Conversion",hash)
|
|
to_email = [self.request.user.email]
|
|
email_code = 'BL1'
|
|
key_value = {
|
|
"service":"PPT Conversion",
|
|
"hash": hash,
|
|
"public key":blockchain_obj.publicKey,
|
|
"private key":private_Key.decode('utf-8'),
|
|
}
|
|
print("::::::::::::::",key_value)
|
|
sendmail(to_email=to_email , email_code=email_code,key_value=key_value, filePath=certificatepath)
|
|
|
|
|
|
|
|
|
|
# For Vetting
|
|
# if request.session
|
|
# obj = ppt.objects.get(script_id=script_id)
|
|
if x.lpp is True:
|
|
print("Making Vetting Request for ppt")
|
|
X = LPPTASKDatabase()
|
|
X.user_id = x.user_id
|
|
X.usernote = "Kindly check if the translated ppt file is correct as per the Uploaded PPT!"
|
|
X.translated_ppt = x
|
|
X.generated_from = "conversion"
|
|
X.amoutgiventolpp_dialogue = self.request.session["lppamount_after_discount"]
|
|
# temp_amount = ((request.session['onlylppfee']) * request.session['team_discount']
|
|
# * request.session['member_discount'] * request.session['running_discount'])
|
|
# X.amoutgiventolpp_action = round((temp_amount/2), 2)
|
|
# X.amoutgiventolpp_dialogue = round((temp_amount/2), 2)
|
|
X.save()
|
|
task_assigner(int(X.task_id), "conversion_ppt")
|
|
print("Making Vetting task Request for ppt")
|
|
|
|
else:
|
|
# temp1 = str(x.upload_ppt)
|
|
# temp = f"{basePath}/media/{temp1}"
|
|
# data = [temp, paths]
|
|
# print(self.request.session["originalppt"])
|
|
# print(data, x.ppt_string, self.request.user.email,
|
|
# " : Passed to blockchain")
|
|
# files, timestamp = upload_multiFile_to_ipfs(
|
|
# data, x.ppt_string, "convertPPT", self.request.user.email)
|
|
# x.timestamp = timestamp
|
|
# x.uploaded_ppt_encoded = files[0]
|
|
# x.translated_ppt_encoded = files[1]
|
|
# print(x.timestamp, x.uploaded_ppt_encoded,
|
|
# x.translated_ppt_encoded, " : Return from Blockchain")
|
|
x.save()
|
|
|
|
# "heading2": f"To view from blockchain use following details: Timestamp - {x.timestamp}, Key - {x.script_title}, Service - convertScript",
|
|
|
|
with open(rf"{basePath}/ideamall/templates/ideamall/body.txt") as f:
|
|
body = f.read()
|
|
|
|
context_email = {
|
|
"Date": date.today(),
|
|
"Name": x.user_id.email,
|
|
"emailcode": "",
|
|
"heading1": "Congratulation! your presentation is converted",
|
|
"heading2": "Thank you for using our service",
|
|
"body": body,
|
|
}
|
|
# import os
|
|
# if os.path.exists(f"{basePath}/media/ppt/converted/{translated_ppt}"):
|
|
# os.remove(f"{basePath}/media/ppt/converted/{translated_ppt}")
|
|
# else:
|
|
# print("The file does not exist")
|
|
# if os.path.exists(original_file_path):
|
|
# os.remove(original_file_path)
|
|
# else:
|
|
# print("The file does not exist")
|
|
# # whomtosend, titleofmail, dateofemail, context\
|
|
# # sendemail(
|
|
# # x.user_id.email,
|
|
# # "conversion complete",
|
|
# # date.today(),
|
|
# # context_email,
|
|
# # EMAIL_HOST_USER,
|
|
# # ).start()
|
|
|
|
# # sendmail(to_email=[x.user_id.email],email_code='CP2')
|
|
# return True
|
|
except Exception as e:
|
|
print("Errorr is", e)
|
|
# write refund code
|
|
x = pptconversion.objects.get(ppt_id=self.ppt)
|
|
auto_refund(x.central_payment_id)
|
|
|
|
|
|
|
|
class ppt_Files_Download(threading.Thread):
|
|
def __init__(self, ppt_file, Path):
|
|
self.ppt_file = ppt_file
|
|
self.Path = Path
|
|
threading.Thread.__init__(self)
|
|
|
|
def run(self):
|
|
download_file_System(self.ppt_file, self.Path)
|
|
|
|
|
|
class ppt_Original_Download(threading.Thread):
|
|
def __init__(self, ppt_file, Path):
|
|
self.ppt_file = ppt_file
|
|
self.Path = Path
|
|
threading.Thread.__init__(self)
|
|
|
|
def run(self):
|
|
download_file_System(self.ppt_file, self.Path)
|
|
|
|
|
|
def get_ppt_script(request):
|
|
if request.method == "POST":
|
|
df = pd.read_csv(rf"{basePath}/lpp/scripts.csv")
|
|
lang1 = request.POST.get("language")
|
|
print(lang1)
|
|
if lang1 == "":
|
|
lang1 = "English"
|
|
print(lang1, " : languages :: types : ", type(lang1))
|
|
|
|
list1_d = df.loc[df[lang1] == "D", "Script"].tolist()
|
|
print("Bakery 20.1: ", list1_d)
|
|
return JsonResponse({"data": list1_d})
|
|
|
|
|
|
# -> Initital Saving of PPT in database and extracting various languages present in that
|
|
def pptcovert(request):
|
|
print("Entered ConversionFunction")
|
|
# print("MY base path is " ,str(BASE_DIR))
|
|
if request.method == "POST":
|
|
start_time = time.time()
|
|
restrict = request.POST.get('restrict')
|
|
print(request.POST)
|
|
x = pptconversion()
|
|
x.ppt_string = str(time.time()) + "-ppt"
|
|
ppt_string = str(time.time()) + "-ppt"
|
|
script_id = int(time.time())
|
|
# request.session["script_id"] = str(script_id)
|
|
MyURL = ""
|
|
dial_src_script = ""
|
|
non_dial_src_lang = ""
|
|
non_dial_src_script = ""
|
|
script_title = ""
|
|
author_name = ""
|
|
numPages = 0
|
|
context = {}
|
|
print("pptuploadedfn")
|
|
user_id = request.user
|
|
x.upload_ppt = request.FILES.get("script")
|
|
file_path = str(request.FILES.get("script"))
|
|
request.session["originalppt"] = f"{basePath}/media/ppt/original/{file_path}"
|
|
x.user_id = request.user
|
|
request.session["pptstring"] = x.ppt_string
|
|
author_name = str(request.user.username)
|
|
script_title = x.upload_ppt.name.split("/")[-1]
|
|
request.session["slide_title"] = script_title
|
|
print("pptuploadedfn2")
|
|
prs = Presentation(x.upload_ppt)
|
|
numPages = len(prs.slides)
|
|
if restrict and numPages > 3:
|
|
numPages = 3
|
|
x.slide_count = numPages
|
|
print("Value of restrict:", restrict)
|
|
print("Number of pages:", numPages)
|
|
|
|
print(len(prs.slides), "pptuploadedfn3")
|
|
x.save()
|
|
|
|
MyURL = "/media/scripts/ppt/" + str(script_title)
|
|
i = 1
|
|
|
|
# Blockchain
|
|
pptconversion1 = {}
|
|
if UserCredentialsForBlockchain.objects.filter(user=request.user).exists():
|
|
blockchain_obj = UserCredentialsForBlockchain.objects.get(user=request.user)
|
|
private_Key = decryptionOfPrivate(blockchain_obj.privateKey)
|
|
contex = request.FILES.get("script")
|
|
with open(f"{basePath}/media/{x.upload_ppt}", 'rb') as _file:
|
|
hash = uploadDataToIPFSNode(_file)
|
|
pptconversion1["ppt_scriptFile_hash"] = hash
|
|
print("my_hash1", hash)
|
|
current_datetime = datetime.datetime.now()
|
|
pptconversion1["slide_count"] = numPages
|
|
pptconversion1["ppt_string"] = ppt_string
|
|
pptconversion1["script_title"] = script_title
|
|
pptconversion1["non_dial_src_lang"] = non_dial_src_lang
|
|
pptconversion1["author_name"] = author_name
|
|
pptconversion1["ppt_scriptFile_path"] = f"{basePath}/media/{x.upload_ppt}"
|
|
pptconversion1["upload_ppt"] = f"{x.upload_ppt}"
|
|
|
|
pptconversion1["date_at"] = current_datetime.strftime(
|
|
"%Y-%m-%d %H:%M:%S")
|
|
hash = hash_decrypation(hash)
|
|
certificatepath = certificateGenrate(request.user.username,"Original PPT",hash)
|
|
|
|
to_email = [request.user.email]
|
|
email_code = 'BL1'
|
|
key_value = {
|
|
"service":"Original PPT",
|
|
"hash": hash,
|
|
"public key":blockchain_obj.publicKey,
|
|
"private key":private_Key.decode('utf-8')
|
|
}
|
|
sendmail(to_email=to_email , email_code=email_code,key_value=key_value,filePath=certificatepath)
|
|
|
|
|
|
|
|
request.session["pptconversion1"] = str(pptconversion1)
|
|
|
|
for slide in prs.slides:
|
|
print("slide number %d" % i)
|
|
i += 1
|
|
etc_list = ["", " ", ",", " ,"]
|
|
sentence = ""
|
|
non_dial_src_lang = ""
|
|
script_use = ""
|
|
print('#9870124555')
|
|
# if slide.shapes[0].text is not None:
|
|
# sentence = slide.shapes[0].text
|
|
if slide.shapes[0].has_text_frame:
|
|
sentence = slide.shapes[0].text
|
|
sentence = re.sub(
|
|
"""[!@#$%^&*()+=}{:;"'<>?/_-]""", "", sentence)
|
|
if len(sentence) < 5:
|
|
continue
|
|
non_dial_src_lang = language_detector(sentence)
|
|
script_use = script_det(sentence)
|
|
if non_dial_src_lang != "" and script_use != "":
|
|
print(i, "slidessssssssssssss")
|
|
print(
|
|
non_dial_src_lang, script_use, "languagesssssssssssssssssssssss"
|
|
)
|
|
break
|
|
else:
|
|
if slide.has_notes_slide:
|
|
text_frame = slide.notes_slide.notes_text_frame
|
|
if len(text_frame.text) > 0:
|
|
try:
|
|
if text_frame.text in etc_list:
|
|
continue
|
|
# print("text", text_frame.text)
|
|
sentence = text_frame.text
|
|
translator = Translator()
|
|
non_dial_src_lang = language_detector(sentence)
|
|
script_use = script_det(sentence)
|
|
if non_dial_src_lang != "" and script_use != "":
|
|
break
|
|
except:
|
|
non_dial_src_lang = ""
|
|
sentence = ""
|
|
script_use = ""
|
|
else:
|
|
break
|
|
|
|
if sentence == "":
|
|
|
|
for shape in slide.shapes:
|
|
if not shape.has_text_frame:
|
|
continue
|
|
for paragraph in shape.text_frame.paragraphs:
|
|
for index, paragraph_run in enumerate(paragraph.runs):
|
|
try:
|
|
if paragraph_run.text in etc_list:
|
|
continue
|
|
sentence = paragraph_run.text
|
|
translator = Translator()
|
|
non_dial_src_lang = language_detector(
|
|
sentence)
|
|
script_use = script_det(sentence)
|
|
if non_dial_src_lang != "" and script_use != "":
|
|
break
|
|
except:
|
|
non_dial_src_lang = ""
|
|
sentence = ""
|
|
script_use = ""
|
|
else:
|
|
break
|
|
|
|
# slide = prs.slides[0]
|
|
# heading = slide.shapes.title.text
|
|
# translator = Translator()
|
|
# non_dial_src_lang = translator.detect(heading)
|
|
# print("00000000000000000000000000000000000000000000000000000000000000000000000000000000000000",
|
|
# non_dial_src_lang.lang)
|
|
# script_use = script_det(heading)
|
|
# print("script used: ", script_use)
|
|
# print("The Data of formInput is:", formInput)
|
|
request.session["script_use"] = script_use
|
|
slang = languages.get(non_dial_src_lang)
|
|
if slang == None:
|
|
slang = "abc"
|
|
context = {
|
|
"id": user_id,
|
|
"numPages": numPages,
|
|
"ppt": x.upload_ppt,
|
|
"option4": languages,
|
|
"fileName": MyURL,
|
|
"non_dial_src_lang": non_dial_src_lang,
|
|
"non_dial_src_lang_full": slang,
|
|
"author_name": author_name,
|
|
"script_title": script_title,
|
|
"Uppt": prs,
|
|
}
|
|
print("-----------------------------------------------")
|
|
print(context)
|
|
end_time = time.time()
|
|
print("-------------Taken Time for input ppt processing->", end_time - start_time)
|
|
return render(request, "conversion/pptupload.html", context)
|
|
return render(request, "conversion/pptupload.html")
|
|
|
|
|
|
def pptDiscountHandler():
|
|
pass
|
|
|
|
|
|
|
|
# -> Actually Running Translation and Transliteration of PPT
|
|
def convertppt(request):
|
|
if request.method == "POST":
|
|
print("request.session variables", )
|
|
for key, value in request.session.items():
|
|
print('{} => {}'.format(key, value))
|
|
for key, value in request.POST.items():
|
|
print('{} => {}'.format(key, value))
|
|
|
|
try:
|
|
x = pptconversion.objects.get(ppt_string=request.session["pptstring"])
|
|
except:
|
|
x = pptconversion()
|
|
x.user_id = request.user
|
|
print("slides number are",x.slide_count)
|
|
try:
|
|
if x.upload_ppt:
|
|
print("exists ")
|
|
|
|
else:
|
|
x.upload_ppt = request.POST.get("fileUpload")
|
|
except:
|
|
x.upload_ppt = request.POST.get("fileUpload")
|
|
source_language = request.POST.get("non_dial_src_lang")
|
|
x.source_lang = languages[source_language]
|
|
try:
|
|
x.source_script = request.session["script_use"]
|
|
except:
|
|
x.source_script = language_script[str(x.source_lang)]
|
|
|
|
x.target_lang = request.POST.get("nondial_dest_language")
|
|
x.target_script = request.POST.get("dial_dest_script")
|
|
restrict = False
|
|
# x.sample = request.POST.get("restrict")
|
|
if request.POST.get("restrict") == 'on':
|
|
x.slide_count = 3
|
|
restrict = True
|
|
print(request.POST.get("to_be_vetted_by_lpp"), "Vetting on or off #787")
|
|
|
|
|
|
#sample blockchain
|
|
try:
|
|
pptconversion1 = eval(request.session["pptconversion1"])
|
|
except:
|
|
pptconversion1 = {}
|
|
if UserCredentialsForBlockchain.objects.filter(user=request.user).exists():
|
|
with open(f"{basePath}/media/{x.upload_ppt}", 'rb') as _file:
|
|
hash = uploadDataToIPFSNode(_file)
|
|
pptconversion1["ppt_scriptFile_hash"] = hash
|
|
print("my_hash1", hash)
|
|
current_datetime = datetime.datetime.now()
|
|
pptconversion1["slide_count"] = request.POST.get("numPages")
|
|
pptconversion1["ppt_string"] = request.POST.get("ppt_string")
|
|
pptconversion1["script_title"] = request.POST.get("script_title")
|
|
pptconversion1["non_dial_src_lang"] = request.POST.get("non_dial_src_lang")
|
|
pptconversion1["author_name"] = request.POST.get("author_name")
|
|
pptconversion1["ppt_scriptFile_path"] = f"{basePath}/media/{x.upload_ppt}"
|
|
pptconversion1["upload_ppt"] = f"{x.upload_ppt}"
|
|
|
|
pptconversion1["date_at"] = current_datetime.strftime(
|
|
"%Y-%m-%d %H:%M:%S")
|
|
|
|
request.session["pptconversion1"] = str(pptconversion1)
|
|
|
|
|
|
|
|
|
|
if request.POST.get("to_be_vetted_by_lpp") == "on":
|
|
x.lpp = True
|
|
pptconversion1["lpp"] = True
|
|
id = x.ppt_id
|
|
request.session["script_id"] = str(id)
|
|
|
|
try:
|
|
if UserCredentialsForBlockchain.objects.filter(user=request.user).exists():
|
|
blockchain_obj = UserCredentialsForBlockchain.objects.get(
|
|
user=request.user)
|
|
|
|
pptconversion1["source_lang"] = languages[source_language]
|
|
pptconversion1["target_lang"] = request.POST.get(
|
|
"nondial_dest_language")
|
|
pptconversion1["target_script"] = request.POST.get(
|
|
"dial_dest_script")
|
|
pptconversion1["ppt_id"] = request.session["script_id"]
|
|
|
|
UserId = blockchain_obj.user_id
|
|
Project = request.session["script_id"]
|
|
# Project = id
|
|
Data = str(pptconversion1)
|
|
userPrivateKey = blockchain_obj.privateKey
|
|
userkey = decryptionOfPrivate(userPrivateKey)
|
|
hash = UploadPPTConversionData(
|
|
OWNER_KEY,blockchain_obj.publicKey, UserId, Project, Data)
|
|
print("my_tx_hash", hash)
|
|
except:
|
|
pass
|
|
if x.slide_count <= 3:
|
|
x.amount = 0
|
|
x.save()
|
|
# with open(rf"{basePath}/ideamall/templates/ideamall/body.txt") as f:
|
|
# body = f.read()
|
|
|
|
# context_email = {
|
|
# "Date": date.today(),
|
|
# "Name": x.user_id.email,
|
|
# "emailcode": "",
|
|
# "heading1": "Thank you!",
|
|
# "heading2": " for using ppt conversion service "
|
|
# + " you will get notification whenever the conversation completes",
|
|
# "body": body,
|
|
# }
|
|
# whomtosend, titleofmail, dateofemail, context\
|
|
# sendemail(
|
|
# x.user_id.email,
|
|
# "Thankyou for using service",
|
|
# date.today(),
|
|
# context_email,
|
|
# EMAIL_HOST_USER,
|
|
# ).start()
|
|
print("Starting conversion of ppt")
|
|
print(x.upload_ppt)
|
|
ppt_conversion(x.ppt_id, request, restrict).start()
|
|
try:
|
|
del request.session["pptstring"]
|
|
except:
|
|
pass
|
|
sendmail(to_email=[x.user_id.email], email_code='CP4')
|
|
sendmail(to_email=[x.user_id.email], email_code='CP9')
|
|
print('is the email working for ppt')
|
|
|
|
print("ending conversion of ppt")
|
|
return render(request, "conversion/thanksppt.html")
|
|
# Blockchain implement
|
|
|
|
|
|
if request.POST.get("to_be_vetted_by_lpp") == "on":
|
|
lpp_available = "yes"
|
|
total_amount = round(int(float(pricing_data('PPT Conversion', 4))) * x.slide_count, 2)
|
|
else:
|
|
lpp_available = "no"
|
|
total_amount = round(int(float(pricing_data('PPT Conversion', 2))) * x.slide_count, 2)
|
|
|
|
print('All discounts ----------------------', centralPayment_get_discounts(request, total_amount))
|
|
pricelist = centralPayment_get_discounts(request, total_amount)
|
|
context = {}
|
|
context["ppt_id"] = id
|
|
request.session["ppt_id"] = str(id)
|
|
|
|
context["sub_total"] = round(total_amount, 2)
|
|
context["membership_discount"] = pricelist["membership_discount_calculate"]
|
|
context["staff_discount"] = pricelist["staff_discount_calculate"]
|
|
context["student_discount"] = pricelist["student_discount_calculate"]
|
|
context["early_bird_discount"] = pricelist["early_bird_calculate"]
|
|
context['total_discount'] = pricelist['total_discount']
|
|
context['net_service_charge'] = pricelist['net_service_charge']
|
|
context["total_payable"] = pricelist["total_payable"]
|
|
context["gst_calculate"] = pricelist["gst_calculate"]
|
|
context["gross_payable"] = pricelist["gross_payable"]
|
|
if request.POST.get("to_be_vetted_by_lpp") == "on":
|
|
calc = round(float((float(pricing_data("PPT Conversion", 4)) - float(pricing_data("PPT Conversion", 2))) / float(pricing_data("PPT Conversion", 4))) * pricelist["total_payable"], 2)
|
|
request.session['lppamount_after_discount'] = calc
|
|
|
|
if not privilegedUser1.objects.filter(user=request.user, is_active="yes").exists():
|
|
context["monthly_membership"] = 1
|
|
|
|
|
|
|
|
|
|
|
|
|
|
#old code to be destoyed
|
|
|
|
|
|
# context = {}
|
|
# context["ppt_id"] = id
|
|
# request.session["ppt_id"] = str(id)
|
|
# print("ending conversion of ppt1")
|
|
# # payment calculation for presentation
|
|
# pdiscount = 1
|
|
# sdiscount = 1
|
|
# mdiscount = 1 - RUNNING_DISCOUNT_CONVERSION / 100
|
|
|
|
# # if not privilegedUser1.objects.filter(
|
|
# # user=request.user, is_active="yes"
|
|
# # ).exists():
|
|
|
|
# # messages.success(request, "Become privileged member")
|
|
# # return redirect("payment")
|
|
# # return True
|
|
|
|
# if not privilegedUser1.objects.filter(
|
|
# user=request.user, is_active="yes"
|
|
# ).exists():
|
|
# # messages.success(request, "Become privileged member")
|
|
# # return redirect("payment")
|
|
# # request.session["directly_pay_monthly"] = 1
|
|
# context = {"directly_pay_monthly": 1}
|
|
# try:
|
|
# memberType = privilegedUser1.objects.get(
|
|
# user=request.user, is_active="yes"
|
|
# ).memberType
|
|
# print("ending conversion of ppt2")
|
|
# if memberType:
|
|
# if memberType == "normal":
|
|
# pdiscount = 1
|
|
# context["pdiscount"] = 0
|
|
# elif memberType == "yearly":
|
|
# pdiscount = 1 - YEARLY_MEMBER_ADDITIONAL / 100
|
|
# context["pdiscount"] = YEARLY_MEMBER_ADDITIONAL
|
|
# elif memberType == "Life Member":
|
|
# pdiscount = 1 - LIFE_MEMBER_ADDITIONAL / 100
|
|
# context["pdiscount"] = LIFE_MEMBER_ADDITIONAL
|
|
# except:
|
|
# pdiscount = 1
|
|
# # sdiscount = 1
|
|
# context["pdiscount"] = 0
|
|
# print("ending conversion of ppt3")
|
|
# if User.objects.get(id=request.user.id).is_staff:
|
|
# sdiscount = 1 - EMPLOY_DISCOUNT / 100
|
|
# else:
|
|
# sdiscount = 1
|
|
# if request.POST.get("to_be_vetted_by_lpp") == "on":
|
|
# lpp_available = "yes"
|
|
# amt = x.slide_count * CONVERSION_PER_PAGE
|
|
# context["total"] = round(amt, 2)
|
|
|
|
# lppamt = (x.slide_count * CONVERSION_PER_PAGE) + (
|
|
# x.slide_count * LPP_PER_PAGE
|
|
# )
|
|
# context["onlylppfee"] = round((x.slide_count * LPP_PER_PAGE), 2)
|
|
# amount_to_be_given_to_lpp = round(
|
|
# mdiscount * context["onlylppfee"] * pdiscount * sdiscount, 2
|
|
# )
|
|
# context["subtotal"] = round(lppamt, 2)
|
|
# context["amount"] = round(
|
|
# mdiscount * lppamt * pdiscount * sdiscount, 2)
|
|
# x.amount = context["amount"]
|
|
# request.session["pptamount"] = context["amount"]
|
|
# context["discount"] = lppamt - context["amount"]
|
|
# request.session["pptdiscount"] = lppamt - context["amount"]
|
|
# request.session["lppamount_after_discount"] = amount_to_be_given_to_lpp
|
|
# request.session["total_amount1"] = context["subtotal"]
|
|
# request.session["amount1"] = context["amount"]
|
|
# request.session["discount1"] = context["discount"]
|
|
# print("ending conversion of ppt4")
|
|
# else:
|
|
# print("ending conversion of ppt5")
|
|
# lpp_available = "no"
|
|
# amt = x.slide_count * CONVERSION_PER_PAGE
|
|
# context["total"] = round(amt, 2)
|
|
# context["subtotal"] = round(amt, 2)
|
|
# context["amount"] = round(
|
|
# mdiscount * amt * pdiscount * sdiscount, 2)
|
|
# context["discount"] = amt - context["amount"]
|
|
# x.amount = context["amount"]
|
|
# request.session["total_amount1"] = context["total"]
|
|
# request.session["amount1"] = context["amount"]
|
|
# request.session["discount1"] = context["discount"]
|
|
# request.session["pptamount"] = context["amount"]
|
|
# request.session["pptdiscount"] = amt - context["amount"]
|
|
# print("ending conversion of ppt6")
|
|
# context["conversion_per_page"] = CONVERSION_PER_PAGE
|
|
# context["lpp_per_page"] = LPP_PER_PAGE
|
|
# context["running_discount_conversion"] = RUNNING_DISCOUNT_CONVERSION
|
|
# context["employ_discount"] = EMPLOY_DISCOUNT
|
|
# context["yearly_member_additional"] = YEARLY_MEMBER_ADDITIONAL
|
|
# context["life_member_additional"] = LIFE_MEMBER_ADDITIONAL
|
|
# context["value_after_rd"] = round(
|
|
# ((context["running_discount_conversion"] / 100)) * context["subtotal"], 2)
|
|
# context["value_after_td"] = round(((context["employ_discount"] / 100)) * (
|
|
# 1 - (context["running_discount_conversion"] / 100)) * context["subtotal"], 2)
|
|
# context["value_after_md"] = round(((context["pdiscount"] / 100)) * (1 - (context["employ_discount"] / 100)) * (
|
|
# 1 - (context["running_discount_conversion"] / 100)) * context["subtotal"], 2)
|
|
context["restrict_to_five"] = "no"
|
|
context["lpp_available"] = lpp_available.upper()
|
|
context["numPages"] = x.slide_count
|
|
# context["script_title"] = x.script_title
|
|
context["ndial_src"] = x.source_lang
|
|
context["ndial_dest"] = x.target_lang
|
|
context["dial_dest_script"] = x.target_script
|
|
context["dial_src_script"] = x.source_script
|
|
context["ppt_title"] = request.session["slide_title"].split(".")[0]
|
|
print("ending conversion of ppt7")
|
|
x.save()
|
|
print("ending conversion of ppt8")
|
|
print("kuch na kaho3456")
|
|
try:
|
|
wall = Wallet.objects.get(user=request.user)
|
|
context["balance"] = round(wall.balance, 2)
|
|
print('Kya na kaho3456')
|
|
except:
|
|
context["balance"] = -1
|
|
with open(f"{basePath}/MNF/json_keys/conversionRates.json") as c:
|
|
curr = json.load(c)
|
|
try:
|
|
rate = curr["rates"]["INR"]
|
|
# c = CurrencyRates()
|
|
# rate = c.get_rate("USD", str(currency.upper()))
|
|
print("kuch na kaho3456789")
|
|
except Exception as e:
|
|
print("checkout error", e)
|
|
rate = 80
|
|
context["rate"] = rate
|
|
|
|
user = User.objects.get(id=request.user.id)
|
|
str1 = str(datetime.datetime.now()).split("-")
|
|
date_at = f'{str1[2][0:2]} - {str1[1]} - {str1[0]}'
|
|
context['date_at'] = date_at
|
|
try:
|
|
cd = centralDatabase.objects.get(user_id=request.user)
|
|
name = cd.firstName if cd.firstName else user.username
|
|
email_id = cd.email if cd.email else user.email
|
|
# phone_number = str(cd.countryCode) + str(cd.contact) if cd.contact else "N/A"
|
|
# address = cd.address if cd.address else "N/A"
|
|
except:
|
|
user = User.objects.get(id=request.user.id)
|
|
name = user.username
|
|
email_id = user.email
|
|
# phone_number = "N/A"
|
|
# address = "N/A"
|
|
|
|
context["name"] = name
|
|
context["email_id"] = email_id
|
|
context["phone_number"] = pricelist['contact'] if pricelist['contact'] else "N/A"
|
|
context["address"] = pricelist['address'] if pricelist['address'] else "N/A"
|
|
request.session['amount'] = context['gross_payable']
|
|
request.session["discount"] = context["total_discount"]
|
|
request.session["subtotal"] = context["sub_total"]
|
|
|
|
|
|
print("kuch na kaho34560000")
|
|
return render(request, "conversion/invoice_pptconversion.html", context)
|
|
|
|
|
|
# -> For Deleting your PPT
|
|
def delete_ppt(request, id):
|
|
# if request.method == "POST":
|
|
# x = pptconversion.objects.get(ppt_id=request.POST.get("pptid"))
|
|
# print(x, 'did i do that or what?')
|
|
# sendmail(to_email=[request.user.email],email_code='CP7')
|
|
sendmail(to_email=[request.user.email], email_code='CP7')
|
|
# pptconversion.objects.get(ppt_id=id).delete()
|
|
if UserCredentialsForBlockchain.objects.filter(user=request.user).exists():
|
|
try:
|
|
blockchain_obj = UserCredentialsForBlockchain.objects.get(
|
|
user=request.user)
|
|
userkey = decryptionOfPrivate(blockchain_obj.privateKey)
|
|
print("funcation is calling.......", userkey.decode(
|
|
'utf-8'), blockchain_obj.user_id, id)
|
|
deletePPTConversion(OWNER_KEY,blockchain_obj.publicKey, blockchain_obj.user_id, id)
|
|
print("funcation called......", userkey.decode(
|
|
'utf-8'), blockchain_obj.user_id, id)
|
|
pptconversion.objects.get(ppt_id=id).delete()
|
|
return HttpResponseRedirect("/conversion/view_conversion")
|
|
except:
|
|
pptconversion.objects.get(ppt_id=id).delete()
|
|
return HttpResponseRedirect("/conversion/view_conversion")
|
|
|
|
else:
|
|
pptconversion.objects.get(ppt_id=id).delete()
|
|
return HttpResponseRedirect("/conversion/view_conversion")
|
|
|
|
|
|
# -> Feedback on Conversion of PPT by User
|
|
def feedback_ppt(request):
|
|
if request.method == "POST":
|
|
x = pptconversion.objects.get(ppt_id=request.POST.get("pptid"))
|
|
if (
|
|
str(request.POST.get("error_text")) == " "
|
|
or str(request.POST.get("error_text")) == ""
|
|
):
|
|
x.error_faced_feedback = ""
|
|
else:
|
|
x.error_faced_feedback = str(request.POST.get("error_text"))
|
|
if request.POST.get("rating") == " " or request.POST.get("rating") == "":
|
|
x.translation_accuracy_rate = 0
|
|
else:
|
|
x.translation_accuracy_rate = int(request.POST.get("rating"))
|
|
x.improvement_feedback = str(request.POST.get("improvement"))
|
|
x.attention_feedback = str(request.POST.get("text"))
|
|
try:
|
|
x.exp_rate = int(request.POST.get("accurate"))
|
|
except:
|
|
pass
|
|
try:
|
|
x.content_accuracy_rate = int(request.POST.get("language"))
|
|
except:
|
|
pass
|
|
x.save()
|
|
with open(rf"{basePath}/ideamall/templates/ideamall/body.txt") as f:
|
|
body = f.read()
|
|
|
|
context_email = {
|
|
"Date": date.today(),
|
|
"Name": x.user_id.email,
|
|
"emailcode": "",
|
|
"heading1": "Thank you!",
|
|
"heading2": " your feedback is very important for us, thankyou for feedback ",
|
|
"body": body,
|
|
}
|
|
# whomtosend, titleofmail, dateofemail, context\
|
|
# sendemail(
|
|
# x.user_id.email,
|
|
# "Feedback recieved",
|
|
# date.today(),
|
|
# context_email,
|
|
# EMAIL_HOST_USER,
|
|
# ).start()
|
|
sendmail(to_email=[x.user_id.email], email_code='CP8')
|
|
print("feedback of ppt mail")
|
|
return redirect("view_conversion")
|
|
|
|
def ppt_tutorial(request):
|
|
return render(request,"conversion/Tutorial_video.html")
|
|
|
|
|
|
|
|
@login_required
|
|
def Get_Existing_Scripts(request):
|
|
scripts = MNFScriptDatabase.objects.filter(user_id = request.user.id).values_list('script_id', 'script_file_path')
|
|
if len(scripts) == 0:
|
|
return JsonResponse({"status":"Success", })
|
|
existing_scripts = {}
|
|
for script in scripts:
|
|
existing_scripts[str((((str(script[1]).split("/"))[-1]).split("."))[0])] = str(script[0])
|
|
return JsonResponse(existing_scripts)
|
|
# <!-- document.getElementById('import').action = "{% url 'load_existingscript' id11 %}"-->
|
|
@login_required
|
|
def load_existing_script(request, id):
|
|
# -> Loading Script
|
|
script = MNFScriptDatabase.objects.get(user_id = request.user, script_id = id)
|
|
MyURL = "/media/" + str(((script.script_file_path).split("/media/"))[-1])
|
|
if script.option3 and script.option4 and script.option5 and script.option6:
|
|
option3 = script.option3
|
|
option4 = script.option4
|
|
option5 = script.option5
|
|
option6 = script.option6
|
|
else:
|
|
formInput = getInputs(request, str(BASE_DIR) + MyURL)
|
|
option3 = formInput[4]
|
|
option4 = formInput[5]
|
|
option5 = formInput[6]
|
|
option6 = formInput[7]
|
|
sampleList = SampleScript.objects.all()
|
|
with open(f"{basePath}/MNF/json_keys/language_pairs.json") as c:
|
|
language_pairs = json.load(c)
|
|
with open(f"{basePath}/MNF/json_keys/script_pairs.json") as c:
|
|
script_pairs = json.load(c)
|
|
context = {
|
|
"id": script.id,
|
|
"numPages": script.numPages,
|
|
"fileName": MyURL,
|
|
"non_dial_src_script": script.nondial_src_script,
|
|
"author_name": script.author_name,
|
|
"script_title": (((str(script.script_title).split("/"))[-1]).split("."))[0],
|
|
"UScript": "UScript",
|
|
"dial_src_script": script.dial_src_script,
|
|
"dial_src_lang": script.dial_src_language,
|
|
"dial_src_lang_full": languages.get(script.dial_src_language),
|
|
"non_dial_src_lang_full": languages.get(script.nondial_src_language),
|
|
"non_dial_src_lang": script.nondial_src_language,
|
|
"list": sampleList,
|
|
"option3": option3,
|
|
"option4": option4,
|
|
"option5": option5,
|
|
"option6": option6,
|
|
"language_pairs": language_pairs,
|
|
"default_script": language_script,
|
|
"script_pairs": script_pairs,
|
|
"existing_script": True,
|
|
}
|
|
print("Redirecting to 2nd Page")
|
|
return render(request, "conversion/conversion.html", context)
|
|
|
|
|
|
def lpp_after_conversion_payment(request):
|
|
obj = ScriptTranslations.objects.get(translation_id=request.POST.get('translation_id'))
|
|
total_amount = round(int(float(pricing_data('Script Conversion', 4))
|
|
- float(pricing_data('Script Conversion', 2))) * obj.script_link_id.numPages, 2)
|
|
|
|
request.session['translation_id'] = request.POST.get('translation_id')
|
|
pricelist = centralPayment_get_discounts(request, total_amount)
|
|
print("pricelist", pricelist)
|
|
|
|
context = {}
|
|
|
|
|
|
context['script_title'] = (((obj.script_link_id.script_file_path.split("/"))[-1]).split("."))[0]
|
|
context['numPages'] = obj.script_link_id.numPages
|
|
context['ndial_src'] = languages[obj.script_link_id.nondial_src_language]
|
|
context['dial_src'] = languages[obj.script_link_id.nondial_src_language]
|
|
context["ndial_dest"] = languages[obj.nondial_dest_language]
|
|
context["dial_dest"] = languages[obj.dial_dest_language]
|
|
context["dial_dest_script"] = obj.dial_dest_script
|
|
|
|
if not privilegedUser1.objects.filter(user=request.user, is_active="yes").exists():
|
|
context["monthly_membership"] = 1
|
|
|
|
context["subtotal"] = round(total_amount, 2)
|
|
context["early_bird_calculate"] = pricelist["early_bird_calculate"]
|
|
context["staff_discount_calculate"] = pricelist["staff_discount_calculate"]
|
|
context["membership_discount_calculate"] = pricelist["membership_discount_calculate"]
|
|
context["student_discount_calculate"] = pricelist["student_discount_calculate"]
|
|
if int(pricelist['student_discount_calculate']) > 0:
|
|
request.session['student_discount_calculate'] = "Yes"
|
|
else:
|
|
request.session['student_discount_calculate'] = "No"
|
|
context['Total_discount'] = pricelist['total_discount']
|
|
context['remaining_amount'] = pricelist['total_payable']
|
|
context["net_service_charge"] = pricelist["net_service_charge"]
|
|
context["gst_calculate"] = pricelist["gst_calculate"]
|
|
context["net_payable"] = pricelist["gross_payable"]
|
|
request.session['amount'] = context["net_payable"]
|
|
request.session['subtotal'] = context["subtotal"]
|
|
request.session['discount'] = context["Total_discount"]
|
|
|
|
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"]
|
|
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
|
|
user = User.objects.get(id=request.user.id)
|
|
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
|
|
|
|
print("7878Context is :", context)
|
|
return render(request, "conversion/invoice_lpp.html", context)
|
|
|
|
|
|
def paymentDoneLpp(request, gateway):
|
|
|
|
if not request.session['translation_id'] or (gateway != "stripe" and gateway != "razorpay"):
|
|
return HttpResponseBadRequest()
|
|
|
|
if gateway == "stripe":
|
|
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":
|
|
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)
|
|
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()
|
|
|
|
|
|
|
|
|
|
elif gateway == "razorpay":
|
|
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)
|
|
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()
|
|
|
|
|
|
obj = ScriptTranslations.objects.get(translation_id=request.session.get('translation_id', None))
|
|
obj.lpp = True
|
|
obj.save()
|
|
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"]
|
|
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")
|
|
return redirect('view_conversion')
|
|
|
|
|
|
|
|
|
|
|
|
def paymentIntentlpp(request):
|
|
if request.method == "POST":
|
|
set_payment_token(request)
|
|
keyID = request.session["keyID"]
|
|
for key, value in request.session.items():
|
|
print('{} => {}'.format(key, value))
|
|
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)
|
|
try:
|
|
rate = curr["rates"]["INR"]
|
|
except Exception as e:
|
|
rate = 80
|
|
print("Checking Wallet")
|
|
wall = Wallet.objects.get(user=request.user)
|
|
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)
|
|
pass
|
|
|
|
request.session["amount"] = total_amount
|
|
services_used = 1
|
|
context = create_indent(request, 'LPP', str(
|
|
request.session['translation_id']), services_used, '', total_amount1, total_amount, amount_discount)
|
|
for key, value in request.session.items():
|
|
print('{} => {}'.format(key, value))
|
|
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:
|
|
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)
|
|
|
|
# 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:
|
|
request.session['central_pay_id'] = context["central_pay_id"]
|
|
context = {
|
|
"mode": "Corporate User",
|
|
}
|
|
return JsonResponse(context)
|