# from tkinter.messagebox import NO
# import phonenumbers
# from project.MNF.narration.views import character_list
# from tkinter import E
import concurrent.futures
import datetime
import io
import json
import logging
import os
import random
import re # added import
import select
import subprocess
import sys
import time
from centralizePayment.models import CentralPayment
import traceback
import zipfile # added import
from io import StringIO
from itertools import zip_longest
from pathlib import Path
from queue import Queue
from subprocess import Popen
import razorpay
import requests
import stripe
from asgiref.sync import async_to_sync
from bs4 import BeautifulSoup
from bs4.element import Comment
from channels.generic.websocket import (AsyncWebsocketConsumer,
WebsocketConsumer)
from channels.layers import get_channel_layer
from django.conf import settings
from django.contrib import messages
from django.contrib.auth.decorators import login_required
from django.contrib.sites.shortcuts import get_current_site
from django.core.files.base import ContentFile
from django.core.mail import EmailMessage, EmailMultiAlternatives
from django.db.models.signals import post_save
from django.dispatch import Signal, receiver
from django.forms import ValidationError as FormValidationError
# sse
from django.http import (HttpResponse, HttpResponseRedirect, JsonResponse,
StreamingHttpResponse)
from django.shortcuts import redirect, render
from django.template import loader
# Multiligule
from django.template.loader import render_to_string
from django.urls import reverse
from django.utils.encoding import force_bytes
from django.utils.html import strip_tags
from django.views import View
from django.views.decorators.csrf import csrf_exempt
from django.views.decorators.http import require_GET
from forex_python.converter import CurrencyRates
from google.cloud import texttospeech
from google.cloud import translate_v2 as Translate
from PyPDF2 import PdfFileReader
from pytz import timezone
from tqdm import tqdm
from urllib3 import HTTPResponse
# Websocket
from auto_email.views import sendmail
from users.models import UserCredentialsForBlockchain
from Blockchain2.decryption import decryptionOfPrivate, decryptionOfUrl, download_file_System
from Blockchain2.DataStorage import uploadDataToIPFSNode
from Blockchain2.Narration import getUserprojectIds,NarrationData,getNarrationData
import tempfile
from Blockchain2.blockchainsetting import (GET_OWNER, SET_ONLY_OWNER,
UPLOAD_FILES)
# from Blockchain2.GetFromBlockChain import getUserprojectIds
from Blockchain2.WalletCreation import walletCreation
from blockchain.submitIPFS import upload_zipfile_to_ipfs
from centralizePayment.views import callback, create_indent
from conversion.forms import CScript, NScript
from conversion.models import UploadScript
from conversion.translation.detection import getInputs
from conversion.translation.translation_function import translate_comparison
from MNF.email import mnfnsendemail
# from neutralAudit import mnf_script_subset_v2 as mnf_ss # 2
# from neutralAudit import sa_functions as sf # 9
# from neutralAudit import sa_functions_english as sf_eng
from MNF.settings import BasePath, GetMongoDBUrl
from mnfapp.models import (Author, MNFScriptDatabase, Notifications,
PaymentData, PitchVector, SampleScript,
centralDatabase)
from narration.vectorcode.code import vector_generation
from neutralAudit_old import mnf_script_subset_v2 as mnf_ss # 2
from neutralAudit_old import sa_functions as sf # 9
from neutralAudit_old import sa_functions_english as sf_eng
from payment.models import privilegedUser1
from Pitchdeck.models import Name, PitchVectorMultiAuthor
# from .models import ProgressBar
from scriptAudit.mnf_script_audit import NeutralAudit
from scriptAudit.models import ScriptAuditModel
from scriptAudit.utils import (check_status_and_trigger_vector,
generate_script_id_for_pitchdeck)
from scriptpage.forms import userForm
from users.models import *
from users.views import deduction_for_sep_wall
from utils import filesystem
from utils.scripts_functions import script_upload
from . import linebyline_narration
# from .Pitchdeck.Character_Introduction import TestingC, Char_function
from .Pitchdeck.Character_Introduction import (Char_audio_class, Char_function,
TestingC, audio_video)
from .Pitchdeck.ElevatorPitch import pitch_function
from .Pitchdeck.onepager import Pager_function
from .Pitchdeck.screenplay import screenplay_main
# from narration.Narration_Code import linebyline_narration
basePath = BasePath()
os.environ["GOOGLE_APPLICATION_CREDENTIALS"] = rf"{basePath}/narration/Narration_Code/authentication.json"
client = texttospeech.TextToSpeechClient()
translate_client = Translate.Client()
#end
PROGRESS = 10
progress_dict = {}
old_progress_dict = {}
from pymongo import MongoClient
# from Character_Introduction.char_function import char_function
# Commented as audit app changed - mohit
# from scriptAudit.script_audit_codes.script_audit import do_script_audit
# from videos.models import Video
logging.basicConfig(filename="./yameen.log",
format='%(asctime)s %(message)s', datefmt='%m/%d/%Y %I:%M:%S %p',level=logging.DEBUG,filemode="a")
# from rest_framework.decorators import (api_view, authentication_classes,
# permission_classes)
# from django.core.mail import EmailMultiAlternatives
# from django.utils.html import strip_tags
# from . import global_database
# from .Narration_Code import narration_generation # see here
# this has been imported by rohit on 26th December 2021
# from .Pitchdeck.Character_Introduction import TestingC
# removed version numbers from blow imports - Amulya 22/12/22
# from neutralAudit import mnf_script_subset_v1 as
MongoDBUrl = GetMongoDBUrl()
# MongoDBUrl="mongodb+srv://mnfv:1234@cluster0.h09hcrq.mongodb.net/?retryWrites=true&w=majority"
print("narration MongodbUrl", MongoDBUrl)
# Create your views here.
#
stripe.api_key = settings.STRIPE_SECRET_KEY
STRIPE_PUB_KEY = settings.STRIPE_PUBLISHABLE_KEY
# keyID = settings.RAZORPAY_KEY_ID
# keySecret = settings.RAZORPAY_KEY_SECRET
UsdConversionRate = 80
# keyID = "rzp_test_6U9A7gZuno8Qz1"
# keySecret = "SrhczTH4dmrxW8SrzeqOdBSP"
progress_updated = Signal()
def set_payment_token(request):
if request.user.is_superuser:
request.session["keyID"] = settings.T_RAZORPAY_KEY_ID
request.session["keySecret"] = settings.T_RAZORPAY_KEY_SECRET
else:
request.session["keyID"] = settings.RAZORPAY_KEY_ID
request.session["keySecret"] = settings.RAZORPAY_KEY_SECRET
# Multiligule
def multilingual_render(req, templateName: str, context: dict):
t = loader.get_template(templateName)
rendered_html = t.render(context, req)
soup = BeautifulSoup(rendered_html, 'html.parser')
def translate_and_replace_text(text):
if "multi_language" in req.session:
trans_text = translate_client.translate(text, source_language="en", target_language=req.session["multi_language"])
return trans_text["translatedText"]
return text
def find_and_replace_text_in_element(element):
with concurrent.futures.ThreadPoolExecutor() as executor:
futures = [executor.submit(translate_and_replace_text, text) for text in element.find_all(text=is_user_visible)]
for future, text in zip(futures, element.find_all(text=is_user_visible)):
if text != '\n':
translated_text = future.result()
text.replace_with(translated_text)
if "multi_language" in req.session:
if req.session["multi_language"] != "en":
target_element = soup.find(id="mulitligule")
if target_element:
find_and_replace_text_in_element(target_element)
target_element_nav = soup.find(id="nav_mulitligual")
if target_element_nav:
find_and_replace_text_in_element(target_element_nav)
footer_elements = soup.find_all('footer')
for footer in footer_elements:
find_and_replace_text_in_element(footer)
modified_html = soup.prettify(encoding="UTF-8")
with open("/home/user/mnf/project/MNF/Pitchdeck/test2024.html", "wb") as file:
file.write(modified_html)
return HttpResponse(modified_html, content_type='text/html; charset=utf-8')
## caution : in case of a variant interpertition the english version will take priority.
def set_language(request):
if request.method == 'POST':
selected_language = request.POST.get('selected_language')
if selected_language:
request.session['multi_language'] = selected_language
with open("/home/user/mnf/project/MNF/Pitchdeck/error_check.txt","a") as file01:
file01.write("multi_language:-" + str(request.session['multi_language']) + str(selected_language)+"\n")
return HttpResponse(status=200)
def is_user_visible(element):
if element.parent.name in ['style', 'script', 'head', 'meta', '[document]']:
return False
elif isinstance(element, Comment):
return False
return True
#end
BASE_DIR = Path(__file__).resolve().parent.parent
demo_files ={
"en":[
["sample_english",rf"{basePath}/media/NarrationDemoVideos/sample_english_pitchdeck.webm", rf"{basePath}/media/NarrationDemoVideos/sample_english.pdf", rf"{basePath}/media/NarrationDemoVideos/sample_english_screenplay.webm", rf"{basePath}/media/NarrationDemoVideos/Character_Introduction.webm",{"characterName":["pravesh","yameen"],"filepath":["pravesh.mp4","yameen.mp4"],}],
],
"hi":[
["yameenHI.docx","/home/user/mnf/project/MNF/media/NarrationDemoVideos/xyz_neha12_line.webm","/home/user/mnf/project/MNF/media/NarrationDemoVideos/newEnglis549_Ra7WQGc.pdf", "/home/user/mnf/project/MNF/media/NarrationDemoVideos/Character_Introduction.webm", "/home/user/mnf/project/MNF/media/NarrationDemoVideos/Character_Introduction.webm", "/home/user/mnf/project/MNF/media/NarrationDemoVideos/AroundYa4_Vuazii8.webm",],
["parveshHi.docx","/home/user/mnf/project/MNF/media/NarrationDemoVideos/xyz_neha12_line.webm","/home/user/mnf/project/MNF/media/NarrationDemoVideos/newEnglis549_Ra7WQGc.pdf", "/home/user/mnf/project/MNF/media/NarrationDemoVideos/Character_Introduction.webm", "/home/user/mnf/project/MNF/media/NarrationDemoVideos/Character_Introduction.webm", "/home/user/mnf/project/MNF/media/NarrationDemoVideos/AroundYa4_Vuazii8.webm",],
],
"fr":[
["sample_french",rf"{basePath}/media/NarrationDemoVideos/sample_french_pitchdeck.webm", rf"{basePath}/media/NarrationDemoVideos/sample_french.pdf", rf"{basePath}/media/NarrationDemoVideos/sample_french_screenplay.webm", rf"{basePath}/media/NarrationDemoVideos/Character_Introduction.webm", " ",],
],
"mr":[
["Sample_Marathi Script", rf"{basePath}/media/NarrationDemoVideos/Sample_Marathi_Script_pitchdeck.webm", rf"{basePath}/media/NarrationDemoVideos/Sample_Marathi_Script.pdf", rf"{basePath}/media/NarrationDemoVideos/Sample_Marathi_Script_screenplay.webm", rf"{basePath}/media/NarrationDemoVideos/Character_Introduction.webm", " ",],
],
}
languages = {
"hi": "Hindi",
"en": "English",
"ur": "Urdu",
"ar": "Arabic",
"bn": "Bengali",
"kn": "Kannada",
"ta": "Tamil",
"bg": "Bulgarian",
"bn": "Bangla",
"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": "Gujrati",
"or": "Odia",
"zh": "Chinese",
"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": "Kazak",
"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",
}
CURRENCY_SYMBOLS_MAP = {
"AED": "د.إ",
"AFN": "؋",
"ALL": "L",
"AMD": "֏",
"ANG": "ƒ",
"AOA": "Kz",
"ARS": "$",
"AUD": "$",
"AWG": "ƒ",
"AZN": "₼",
"BAM": "KM",
"BBD": "$",
"BDT": "৳",
"BGN": "лв",
"BHD": ".د.ب",
"BIF": "FBu",
"BMD": "$",
"BND": "$",
"BOB": "$b",
"BRL": "R$",
"BSD": "$",
"BTC": "฿",
"BTN": "Nu.",
"BWP": "P",
"BYR": "Br",
"BYN": "Br",
"BZD": "BZ$",
"CAD": "$",
"CDF": "FC",
"CHF": "CHF",
"CLP": "$",
"CNY": "¥",
"COP": "$",
"CRC": "₡",
"CUC": "$",
"CUP": "₱",
"CVE": "$",
"CZK": "Kč",
"DJF": "Fdj",
"DKK": "kr",
"DOP": "RD$",
"DZD": "دج",
"EEK": "kr",
"EGP": "£",
"ERN": "Nfk",
"ETB": "Br",
"ETH": "Ξ",
"EUR": "€",
"FJD": "$",
"FKP": "£",
"GBP": "£",
"GEL": "₾",
"GGP": "£",
"GHC": "₵",
"GHS": "GH₵",
"GIP": "£",
"GMD": "D",
"GNF": "FG",
"GTQ": "Q",
"GYD": "$",
"HKD": "$",
"HNL": "L",
"HRK": "kn",
"HTG": "G",
"HUF": "Ft",
"IDR": "Rp",
"ILS": "₪",
"IMP": "£",
"INR": "₹",
"IQD": "ع.د",
"IRR": "﷼",
"ISK": "kr",
"JEP": "£",
"JMD": "J$",
"JOD": "JD",
"JPY": "¥",
"KES": "KSh",
"KGS": "лв",
"KHR": "៛",
"KMF": "CF",
"KPW": "₩",
"KRW": "₩",
"KWD": "KD",
"KYD": "$",
"KZT": "₸",
"LAK": "₭",
"LBP": "£",
"LKR": "₨",
"LRD": "$",
"LSL": "M",
"LTC": "Ł",
"LTL": "Lt",
"LVL": "Ls",
"LYD": "LD",
"MAD": "MAD",
"MDL": "lei",
"MGA": "Ar",
"MKD": "ден",
"MMK": "K",
"MNT": "₮",
"MOP": "MOP$",
"MRO": "UM",
"MRU": "UM",
"MUR": "₨",
"MVR": "Rf",
"MWK": "MK",
"MXN": "$",
"MYR": "RM",
"MZN": "MT",
"NAD": "$",
"NGN": "₦",
"NIO": "C$",
"NOK": "kr",
"NPR": "₨",
"NZD": "$",
"OMR": "﷼",
"PAB": "B/.",
"PEN": "S/.",
"PGK": "K",
"PHP": "₱",
"PKR": "₨",
"PLN": "zł",
"PYG": "Gs",
"QAR": "﷼",
"RMB": "￥",
"RON": "lei",
"RSD": "Дин.",
"RUB": "₽",
"RWF": "R₣",
"SAR": "﷼",
"SBD": "$",
"SCR": "₨",
"SDG": "ج.س.",
"SEK": "kr",
"SGD": "$",
"SHP": "£",
"SLL": "Le",
"SOS": "S",
"SRD": "$",
"SSP": "£",
"STD": "Db",
"STN": "Db",
"SVC": "$",
"SYP": "£",
"SZL": "E",
"THB": "฿",
"TJS": "SM",
"TMT": "T",
"TND": "د.ت",
"TOP": "T$",
"TRL": "₤",
"TRY": "₺",
"TTD": "TT$",
"TVD": "$",
"TWD": "NT$",
"TZS": "TSh",
"UAH": "₴",
"UGX": "USh",
"USD": "$",
"UYU": "$U",
"UZS": "лв",
"VEF": "Bs",
"VND": "₫",
"VUV": "VT",
"WST": "WS$",
"XAF": "FCFA",
"XBT": "Ƀ",
"XCD": "$",
"XOF": "CFA",
"XPF": "₣",
"YER": "﷼",
"ZAR": "R",
"ZWD": "Z$",
"XPD": "Pd",
"ZMK": "ZK",
"VEB": "Bs",
"SDD": "SD",
"ESP": "Pt",
"SKK": "Sk",
"RUR": "₽",
"ROL": "RON",
"PLZ": "zł",
"XPD": "Pd oz",
"NLG": "ƒ",
"MXP": "$",
"LUF": "F",
"ITL": "ITL",
"IEP": "£",
"GRD": "₯",
"XAU": "XAU",
"DEM": "DEM",
"FRF": "Fr",
"FIM": "Mk",
"NLG": "ƒ",
"CSK": "Kčs",
"CYP": "C£",
"BGL": "лв",
"BEF": "ƒ",
"ATS": "ATS",
"ARP": "$",
"XPT": "XPT",
"PTE": "₠",
"XDR": "XDR",
"XAG": "XAG",
"XPD": "XPD",
}
# from .serializers import ProgressBarSerializer
# from rest_framework.response import Response
# @api_view(['GET'])
# def progressBar(request,userid):
# if request.method == "GET":
# if id is not None:
# main = ProgressBar.objects.all().filter(id=userid)
# serializer = ProgressBarSerializer(main, many=True)
# return Response(serializer.data)
# main = ProgressBar.objects.all().filter(id = userid)
# serializer = ProgressBarSerializer(main, many=True)
# return Response(serializer.data)
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()
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
def narration(request):
number = ReferUser.objects.filter(refferedBy=request.user).count()
file_pk = request.GET.get("file_detail")
if file_pk:
file_qry = MNFScriptDatabase.objects.filter(script_id=file_pk).first()
else:
file_qry = None
M = MNFScriptDatabase()
sampleList = SampleScript.objects.filter(status="N")
MyURL = ""
dial_src_script = ""
dial_src_lang = ""
non_dial_src_lang = ""
non_dial_src_script = ""
script_title = ""
author_name = ""
numPages = 0
UScript = CScript()
id = ""
x = datetime.datetime.now(timezone("UTC")).astimezone(
timezone("Asia/Kolkata"))
# print("MY base path is " ,str(BASE_DIR))
UploadedScript = UploadScript()
print(" Upar Aaa rha hai")
if request.method == "POST":
M.script = request.FILES["script"]
if request.POST.get("linebyline"):
M.linebyline = "True"
if request.POST.get("characterintro"):
M.character_intro = "True"
if request.POST.get("screenplayanalysis"):
M.screenplay_analysis = "True"
M.save()
MyURL = M.script.url
# UScript = CScript(request.POST, request.FILES)
# if UScript.is_valid():
# UploadedScript.script = UScript.cleaned_data.get("script")
# MyURL = UploadedScript.script.url
print(MyURL)
print("$$$$$$$$$$$$$$$$$$$$$$$$$$$$$" * 4)
# UploadedScript.save()
# script_title = MyURL[7:-5] + str(x.strftime("%d"))+ "_"+ str(x.strftime("%b"))+ "_"+ str(x.strftime("%H"))+ str(x.strftime("%I"))
author_name = str(request.user.username)
# ------------------neha
request.session["script_name"] = M.script.name
script_title = request.session["script_name"]
# script_title = script_title[8:]
if script_title[-3:] == "pdf":
print(
"This do_script_audit start->",
datetime.datetime.now(timezone("UTC")).astimezone(
timezone("Asia/Kolkata")
),
)
# print(do_script_audit(basePath + MyURL, "1234", "scripts"))
print(
"This do_script_audit end->",
datetime.datetime.now(timezone("UTC")).astimezone(
timezone("Asia/Kolkata")
),
)
pdf = PdfFileReader(open(rf"{basePath}/{MyURL}", "rb"))
numPages = pdf.getNumPages()
# MyURL = MyURL[:-3]+"docx"
else:
numPages = countPages(str(BASE_DIR) + MyURL,
script_title[7:-4] + "pdf")
print(
"This do_script_audit start->",
datetime.datetime.now(timezone("UTC")).astimezone(
timezone("Asia/Kolkata")),
)
formInput = getInputs(str(BASE_DIR) + MyURL)
print(
"This do_script_audit end->",
datetime.datetime.now(timezone("UTC")).astimezone(
timezone("Asia/Kolkata")),
)
dial_src_script = formInput[2]
dial_src_lang = formInput[1]
non_dial_src_lang = formInput[0]
non_dial_src_script = formInput[3]
print("done")
return render(
request,
"narration/narration.html",
{
"numPages": numPages,
"id": M.id,
"list": sampleList,
"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,
"file": file_qry,
"number": number,
},
)
def get_page_count(file):
archive = zipfile.ZipFile(file, "r")
ms_data = archive.read("doc/docx")
archive.close()
app_xml = ms_data.decode("utf-8")
regex = r"<(Pages|Slides)>(\d)</(Pages|Slides)>"
matches = re.findall(regex, app_xml, re.MULTILINE)
match = matches[0] if matches[0:] else [0, 0]
page_count = match[1]
return page_count
def characterNarrate(request):
print("characterNarrate starting here")
if request.method == "POST":
print("characterNarrate POST starting here")
selected_character = request.POST.getlist("character_check")
print(f" selected characters {selected_character}")
# Pitchvector-- Add a field for selected Character list and save
input_dir = request.session.get("script_dir_url")
print(f"input dir {input_dir}")
# input_filename=request.session["script_name"]
input_filename = request.session["script_name"]
print("enter subset characters")
dic_of_chr_path = mnf_ss.get_subset_character_script(
input_dir, input_filename, selected_character
)
print(dic_of_chr_path)
print("exit subset characters")
return render(
request,
"Pitchdeck/Pitchnarrate2.html",
{"script": request.session["script_name"][:-5]},
)
return render(
request,
"Pitchdeck/characterNarration.html",
{"character_list": request.session["saved_characters_list"]},
)
# @login_required(login_url="/")
def pitchnarrate_view(request):
number = ReferUser.objects.filter(refferedBy=request.user).count()
print("Delhi India: 0")
screenplay_form = userForm(request.POST, request.FILES)
if request.method == "POST":
logging.debug("in pitchnarrate_view")
if not screenplay_form.is_valid():
raise screenplay_form.error_class
logging.debug(screenplay_form.changed_data)
screenplay_name = screenplay_form.cleaned_data["screenplay"]
author = screenplay_form.cleaned_data["author"]
language = screenplay_form.cleaned_data["language"]
script_file = screenplay_form.cleaned_data["file"]
# script_file = screenplay_form.cleaned_data["file"]
script_ext = script_file.name.split(".")[-1]
script_file_name = screenplay_name + "." + script_ext
file = ContentFile(
script_file.read(),
script_file_name,
)
script_data = filesystem.new_screenplay(
request.user,
author,
screenplay_name,
file,
"script-original",
language,
)
request.session["script_name"] = script_data.get("name")
request.session["line_by_line_narration"] = request.POST.get(
"line_by_line_narration"
)
request.session["character_introduction"] = request.POST.get(
"character_introduction"
)
request.session["screenplay_analysis"] = request.POST.get(
"screenplay_analysis")
request.session["one_pager"] = request.POST.get("one_pager")
request.session["elevator_pitch"] = request.POST.get("elevator_pitch")
request.session["character_narration"] = request.POST.get(
"character_narration")
script_id = script_data.get("script").get("id")
print("new Delhi India: 1")
z = PitchVector()
while True:
audit_model = ScriptAuditModel.objects.get(script__id=script_id)
if audit_model.status == "SUCCESS":
break
elif audit_model.status == "FAILURE":
raise Exception("Audit Failed")
print("apple100")
file = filesystem.get_script(script_id, "script-docx", create=True)
z.choosescript = file
z.save()
request.session["script_url"] = file.path
print(
"apple101 _______________________________________________________________________________\n\n",
file.path,
)
request.session["script_dir_url"] = str(BASE_DIR) + "/media/scripts/"
print("harsh")
formInput = getInputs(file.path)
dial_src_script = formInput[2]
dial_src_lang = formInput[1]
non_dial_src_lang = formInput[0]
non_dial_src_script = formInput[3]
print("done")
request.session["dial_src_script"] = dial_src_script
request.session["dial_src_lang"] = dial_src_lang
request.session["non_dial_src_lang"] = non_dial_src_lang
request.session["non_dial_src_script"] = non_dial_src_script
print("character started")
request.session["line_by_line_narration"] = request.POST.get(
"line_by_line_narration"
)
request.session["character_introduction"] = request.POST.get(
"character_introduction"
)
request.session["screenplay_analysis"] = request.POST.get(
"screenplay_analysis")
request.session["one_pager"] = request.POST.get("one_pager")
request.session["elevator_pitch"] = request.POST.get("elevator_pitch")
request.session["character_narration"] = request.POST.get(
"character_narration")
print("checklbl", request.session["line_by_line_narration"])
print("checkci", request.session["character_introduction"])
print("checksa", request.session["screenplay_analysis"])
print("checkop", request.session["one_pager"])
print("checkep", request.session["elevator_pitch"])
print("checkcn", request.session["character_narration"])
input_dir = str(BASE_DIR) + "/media/scripts/"
input_filename = request.session["script_name"]
print("----------OM----------view")
print(input_dir)
# char_list = mnf_ss.get_character_list(input_dir, input_filename)
audit = NeutralAudit(script_id)
char_list = audit.get_character_list()
request.session["saved_characters_list"] = list(char_list)
print("get_character_list done")
char_list1 = list(char_list)
script_upload(file, request.user)
if len(char_list1) > 2:
newlist = char_list1[0:2]
else:
newlist = char_list1
no_of_char = len(newlist)
print(
"\n\n\n+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++\n\n\n"
)
print("checkcn", request.session.items())
print(
"\n\n\n+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++\n\n\n"
)
# if no_of_char == 1:
# return render(
# request,
# "Pitchdeck/Pitchnarrate2.html",
# {
# "script": request.session["script_name"],
# "character_list": char_list1,
# "firstcharacter": newlist[0],
# "five_character": newlist,
# "cd": centralDatabase.objects.get(user_id=request.user),
# },
# )
# else:
# return render(
# request,
# "Pitchdeck/Pitchnarrate2.html",
# {
# "script": request.session["script_name"],
# "character_list": char_list1,
# "firstcharacter": newlist[0],
# "secondcharacter": newlist[1],
# "five_character": newlist,
# "cd": centralDatabase.objects.get(user_id=request.user),
# },
# )
return render(
request,
"Pitchdeck/pitchnarratefile.html",
{"number": number, "formInput": screenplay_form},
)
@login_required(login_url="/")
def Pitchnarrate_yameen(request):
# print("request",request)
print("request.user",request.user)
number = ReferUser.objects.filter(refferedBy=request.user).count()
# print("Delhi India: 1")
z = PitchVector()
if request.method == "POST":
# UScript = NScript(request.POST, request.FILES)
# print("request.FILES", request.FILES)
# print('UScript',UScript)
# if UScript.is_valid():
# z.choosescript = UScript.cleaned_data.get("scriptss")
# # print("****************************777777777778888888889999999999999**************************")
# print('z.choosescript', z.choosescript)
# z.save()
# # filename = UScript.cleaned_data.get("scriptss")
# aa = re.sub("[^A-Za-z0-9 /._]+", "", str(z.choosescript))
# print("aa",aa)
# # bb = aa.replace(" ", "_")
# # print(bb)
# filename = str(aa).replace(" ", "_")
# filename = filename[8:]
id = request.POST.get("Nscript_id")
print("Iddddddddd", type(id))
x = SampleScript.objects.get(id=id)
filePath = x.script_file_path
filename = filePath.split('/')[-1]
print("filenamessssssssssssssssssss", filename)
z.choosescript = filename
z.save()
request.session["script_name"] = filename
file_url = str(BASE_DIR) + "/media/scripts/" + filename
print("file_urlss", file_url)
request.session["script_url"] = file_url
# used because get_subset_character_script needs file dir
request.session["script_dir_url"] = str(BASE_DIR) + "/media/scripts/"
print("harsh")
formInput = getInputs(file_url)
dial_src_script = formInput[2]
dial_src_lang = formInput[1]
non_dial_src_lang = formInput[0]
non_dial_src_script = formInput[3]
print("done")
request.session["dial_src_script"] = dial_src_script
request.session["dial_src_lang"] = dial_src_lang
request.session["non_dial_src_lang"] = non_dial_src_lang
request.session["non_dial_src_script"] = non_dial_src_script
print("character started")
checkedopt = []
print(request.POST.get("line_by_line_narration"))
request.session["line_by_line_narration"] = request.POST.get(
"line_by_line_narration"
)
request.session["character_introduction"] = request.POST.get(
"character_introduction"
)
request.session["screenplay_analysis"] = request.POST.get(
"screenplay_analysis")
request.session["one_pager"] = request.POST.get("one_pager")
request.session["elevator_pitch"] = request.POST.get("elevator_pitch")
request.session["character_narration"] = request.POST.get(
"character_narration")
input_dir = str(BASE_DIR) + "/media/scripts/"
input_filename = filename
print("----------OM----------yameen")
print(input_dir)
char_list = mnf_ss.get_character_list(input_dir, input_filename)
print(char_list)
request.session["saved_characters_list"] = list(char_list)
print("get_character_list done")
numPages = countPages(file_url, file_url.rsplit(
"/", 1)[1].rsplit(".", 1)[0] + ".pdf")
print("no of page", numPages)
if numPages > 5:
try:
membertype = privilegedUser1.objects.get(
user=request.user, is_active="yes")
print("neha privalige", membertype)
char_list1 = list(char_list)
# script_upload(filePat, request.user)
if len(char_list1) > 2:
newlist = char_list1[0:2]
else:
newlist = char_list1
no_of_char = len(newlist)
if no_of_char == 1:
return render(
request,
"Pitchdeck/Pitchnarrate2.html",
{
"script": filename[:-5],
"character_list": char_list1,
"firstcharacter": newlist[0],
"five_character": newlist,
"cd": centralDatabase.objects.get(user_id=request.user),
"numPages": numPages,
},
)
else:
return render(
request,
"Pitchdeck/Pitchnarrate2.html",
{
"script": filename[:-5],
"character_list": char_list1,
"firstcharacter": newlist[0],
"secondcharacter": newlist[1],
"five_character": newlist,
"cd": centralDatabase.objects.get(user_id=request.user),
"numPages": numPages,
},
)
except:
messages.error(request, "You are not a privileged member.")
return render(request, "Pitchdeck/Pitchnarrate1.html")
# return redirect("payment")
else:
char_list1 = list(char_list)
# script_upload(filePath, request.user)
if len(char_list1) > 2:
newlist = char_list1[0:2]
else:
newlist = char_list1
no_of_char = len(newlist)
if no_of_char == 1:
return render(
request,
"Pitchdeck/Pitchnarrate2.html",
{
"script": filename[:-5],
"character_list": char_list1,
"firstcharacter": newlist[0],
"five_character": newlist,
"cd": centralDatabase.objects.get(user_id=request.user),
"numPages": numPages,
},
)
else:
return render(
request,
"Pitchdeck/Pitchnarrate2.html",
{
"script": filename[:-5],
"character_list": char_list1,
"firstcharacter": newlist[0],
"secondcharacter": newlist[1],
"five_character": newlist,
"cd": centralDatabase.objects.get(user_id=request.user),
"numPages": numPages,
},
)
return render(request, "Pitchdeck/Pitchnarrate1.html", {"number": number})
@login_required(login_url="/")
def Pitchnarrate1(request, id=None):
print("request", request)
print("request.user", request.user.email)
number = ReferUser.objects.filter(refferedBy=request.user).count()
print("Delhi India: 1")
Module= "narration"
servicesName = "PitchdeckCreation"
z = PitchVector()
if request.method == "POST":
# if 'form_identifier' in request.POST:
# print("############################# TRUE ###################################################")
# print('request.FILES["scriptss"]',request.FILES["scriptss"])
# fileExists = script_upload(request.FILES["scriptss"], request.user, 1)
# print("fileExists",fileExists)
# return render(request, "Pitchdeck/Pitchnarrate1.html")
# MongoDBUrl = "mongodb+srv://MNF:root@cluster0.gbkxi.gcp.mongodb.net/DB?retryWrites=true&w=majority"
MongoDBUrl = "mongodb+srv://mynextfilm:mnf123@cluster0.ojasb.mongodb.net/myFirstDatabase?retryWrites=true&w=majority"
client = MongoClient(MongoDBUrl)
db = client.DB
# try:
try:
# script_upload(request.FILES["scriptss"], request.user)
fileExists = script_upload(request.FILES["scriptss"], request.user, 1)
if fileExists:
# pitch_data = db["mnfapp_pitchvector"].find_one({"script_id": str(script_id)})
print("scriptName########////", str(request.FILES["scriptss"].name))
s_name=str(request.FILES["scriptss"].name)
# numPages = countPages(s_name, s_name.rsplit("/", 1)[1].rsplit(".", 1)[0] + ".pdf")
# print("with file exist",numPages)
sript_title=s_name.split(".")[0]
user_script_data = db["mnfapp_mnfscriptdatabase"].find_one({"script_title": sript_title})
print("user_script_data ##########################",user_script_data)
if user_script_data:
recent_id=user_script_data.get('script_id')
if user_script_data['characterwise_narration']=='True'or user_script_data['linebyline']=='True'or user_script_data['screenplay_analysis']=='True'or user_script_data['character_intro']=='True' or user_script_data['onepager']=='True'or user_script_data['elevator_pitch']=='True':
script_database = db["mnfapp_pitchvector"].find_one({"script_id":recent_id})
print(script_database)
else:
pass
else:
pass
except Exception as e:
error = e
return render(request, "Pitchdeck/Pitchnarrate1.html", {"error":error})
UScript = NScript(request.POST, request.FILES)
print("request.FILES", request.FILES)
print('UScript', UScript)
if UScript.is_valid():
z.choosescript = UScript.cleaned_data.get("scriptss")
print('z.choosescript', z.choosescript)
z.save()
# filename = UScript.cleaned_data.get("scriptss")
# aa = re.sub("[^A-Za-z0-9 /._]+", "", str(z.choosescript))
# print("aa", aa)
# # bb = aa.replace(" ", "_")
# # print(bb)
# filename = str(aa).replace(" ", "_")
filename = str(z.choosescript)
filename = filename[8:]
#Blockchain
if UserCredentialsForBlockchain.objects.filter(user=request.user).exists():
blockchain_obj = UserCredentialsForBlockchain.objects.get(user=request.user)
contex = z.choosescript
hash = uploadDataToIPFSNode(contex)
print("hash;;;;;;;;>>",hash)
request.session["original_script_file_hash"] = hash
# :::::::::::::
# print("filename................................>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>...................>>>>>>>>>>>>>>>>..", filename)
# print(filename.name)
request.session["script_name"] = filename
file_url = str(BASE_DIR) + "/media/scripts/" + filename
print("file_url", file_url)
request.session["script_url"] = file_url
with open("/home/user/mnf/project/MNF/Pitchdeck/error_check.txt","a") as file01:
file01.write("f: " + str(file_url) + "\n")
# used because get_subset_character_script needs file dir
request.session["script_dir_url"] = str(BASE_DIR) + "/media/scripts/"
print("harsh")
try:
# print("Entered Try *&*&*&*&*&")
# formInput = getInputs(file_url)
with open("/home/user/mnf/project/MNF/Pitchdeck/error_check.txt","a") as file01:
file01.write("In Try block" + "\n")
print("entered Try :::::::::::::::")
formInput = getInputs(file_url)
with open("/home/user/mnf/project/MNF/Pitchdeck/error_check.txt","a") as file01:
file01.write("form data: " + str(formInput ) + "\n")
dial_src_script = formInput[2]
with open("/home/user/mnf/project/MNF/Pitchdeck/error_check.txt","a") as file01:
file01.write("dial_src_script data: " + str(dial_src_script ) + "\n")
dial_src_lang = formInput[1]
with open("/home/user/mnf/project/MNF/Pitchdeck/error_check.txt","a") as file01:
file01.write("dial_src_langa: " + str(dial_src_lang ) + "\n")
non_dial_src_lang = formInput[0]
with open("/home/user/mnf/project/MNF/Pitchdeck/error_check.txt","a") as file01:
file01.write("non_dial_src_lang: " + str(non_dial_src_lang ) + "\n")
non_dial_src_script = formInput[3]
with open("/home/user/mnf/project/MNF/Pitchdeck/error_check.txt","a") as file01:
file01.write("non_dial_src_script: " + str(non_dial_src_script ) + "\n")
print("done")
request.session["dial_src_script"] = dial_src_script
request.session["dial_src_lang"] = dial_src_lang
request.session["non_dial_src_lang"] = non_dial_src_lang
request.session["non_dial_src_script"] = non_dial_src_script
except:
error = "Could not process this type of file"
return render(request, "Pitchdeck/Pitchnarrate1.html", {"error": error})
print("character started")
checkedopt = []
# print(request.POST.get("line_by_line_narration"))
request.session["line_by_line_narration"] = request.POST.get(
"line_by_line_narration"
)
request.session["character_introduction"] = request.POST.get(
"character_introduction"
)
request.session["screenplay_analysis"] = request.POST.get(
"screenplay_analysis")
request.session["one_pager"] = request.POST.get("one_pager")
request.session["elevator_pitch"] = request.POST.get("elevator_pitch")
request.session["character_narration"] = request.POST.get(
"character_narration")
print("charWise")
print(request.session["character_narration"])
services_use = []
if request.session["line_by_line_narration"] == "Line by Line Narration(Video)":
print(request.session["line_by_line_narration"])
with open("/home/user/mnf/project/MNF/Pitchdeck/error_check.txt","a") as file01:
file01.write("Line by line1: " + str(request.session["line_by_line_narration"]) + "\n")
services_use.append("Line by Line Narration")
if request.session["character_introduction"] == "Character Introduction(Video)":
print(request.session["character_introduction"])
with open("/home/user/mnf/project/MNF/Pitchdeck/error_check.txt","a") as file01:
file01.write("Character introduction1: " + str(request.session["character_introduction"]) + "\n")
services_use.append("Character Introduction")
if request.session["screenplay_analysis"] == "Screenplay Analysis(Video)":
print(request.session["screenplay_analysis"])
with open("/home/user/mnf/project/MNF/Pitchdeck/error_check.txt","a") as file01:
file01.write("Screenplay analysis1: " + str(request.session["screenplay_analysis"]) + "\n")
services_use.append("Screenplay Analysis")
if request.session["elevator_pitch"] == "Elevator Pitch(Video)":
print(request.session["elevator_pitch"])
with open("/home/user/mnf/project/MNF/Pitchdeck/error_check.txt","a") as file01:
file01.write("Elevator pitch1: " + str(request.session["elevator_pitch"]) + "\n")
services_use.append("Elevator Pitch")
if request.session["one_pager"] == "One Pager(PDF)":
print(request.session["one_pager"])
with open("/home/user/mnf/project/MNF/Pitchdeck/error_check.txt","a") as file01:
file01.write("One pager1: " + str(request.session["one_pager"]) + "\n")
services_use.append("One Pager")
if request.session["character_narration"] == "Characterwise Narration(Video)":
print(request.session["character_narration"])
with open("/home/user/mnf/project/MNF/Pitchdeck/error_check.txt","a") as file01:
file01.write("Character narration1: " + str(request.session["character_narration"]) + "\n")
services_use.append("Characterwise Narration")
input_dir = str(BASE_DIR) + "/media/scripts/"
input_filename = filename
print("----------OM----------")
print(input_dir)
#----------------------modified audit part
input_script_path = os.path.join(input_dir,input_filename) #paveen
print("input_script_path:::::::::::", input_script_path)
script_id_audit = generate_script_id_for_pitchdeck(input_script_path,request)
request.session["script_id_audit"] = script_id_audit
print('Yameenmrequest.session["script_id_audit"]', request.session["script_id_audit"])
print("neutral audit started---------------")
with open("/home/user/mnf/project/MNF/Pitchdeck/error_check.txt","a") as file01:
file01.write("1.neutral audit started---------------" + "\n")
try:
neutral_aud = NeutralAudit(script_id_audit)
print("neutral audit ended-----------")
char_lst = neutral_aud.get_character_list()
except:
char_lst = None
error = "Our Services are currently not available"
return render(request, "Pitchdeck/Pitchnarrate1.html", {"error": error})
with open("/home/user/mnf/project/MNF/Pitchdeck/error_check.txt","a") as file01:
file01.write("char list ended-------------------------" + "\n")
print("2.neutral audit ended-------------------------")
print("HERE IS THE CHARACTER SUBSET",str(char_lst))
# dist_audit_character_subset = script_audit_obj.get_character_subset(char_list)
char_list = char_lst
#---------------------------------------------end--------------------------
with open("/home/user/mnf/project/MNF/Pitchdeck/error_check.txt","a") as file01:
file01.write("3.LIST of CHARACTERS: " + str(char_list) + "\n")
# print("dist_audit_character_subsetyameen",dist_audit_character_subset)
# request.session["dist_audit_character_subset"] = dist_audit_character_subset
# char_list = mnf_ss.get_character_list(input_dir, input_filename)
print("char_list________________________________________________",char_list)
request.session["saved_characters_list"] = list(char_list)
print("get_character_list done")
numPages = countPages(file_url, file_url.rsplit(
"/", 1)[1].rsplit(".", 1)[0] + ".pdf")
print("no of page", numPages)
# if numPages > 5:
# try:
# membertype = privilegedUser1.objects.filter(user=request.user, is_active="yes")
# print("neha privalige", membertype)
# char_list1 = list(char_list)
# if len(char_list1) > 2:
# newlist = char_list1[0:2]
# else:
# newlist = char_list1
# no_of_char = len(newlist)
# print("........",newlist)
# print(">>>>>>>>>>>>>charlenght",no_of_char)
# if no_of_char == 1:
# return render(
# request,
# "Pitchdeck/Pitchnarrate2.html",
# {
# "script": filename[:-5],
# "character_list": char_list1,
# "numberofcharacter": len(char_list1),
# "firstcharacter": newlist[0],
# "five_character": newlist,
# "cd": centralDatabase.objects.get(user_id=request.user),
# "numPages": numPages,
# "user_name": request.user.username,
# "user_email": request.user.email,
# "services_use": services_use,
# "services_len": len(services_use),
# # "script_database": script_database
# },
# )
# else:
# return render(
# request,
# "Pitchdeck/Pitchnarrate2.html",
# {
# "script": filename[:-5],
# "character_list": char_list1,
# "numberofcharacter": len(char_list1),
# "firstcharacter": newlist[0],
# "secondcharacter": newlist[1],
# "five_character": newlist,
# "cd": centralDatabase.objects.get(user_id=request.user),
# "numPages": numPages,
# "user_name": request.user.username,
# "user_email": request.user.email,
# "services_use": services_use,
# "services_len": len(services_use),
# # "script_database": script_database
# },
# )
# except:
# messages.error(request, "You are not a privileged member.")
# print("@@@@@@@@ privileged member nahi hai hai @@@@@@@@@@@@@@@@")
# return render(request, "Pitchdeck/Pitchnarrate1.html")
# # return redirect("payment")
# else:
char_list1 = list(char_list)
print("char_list", char_list1)
if len(char_list1) > 2:
newlist = char_list1[0:2]
else:
newlist = char_list1
no_of_char = len(newlist)
with open("/home/user/mnf/project/MNF/Pitchdeck/error_check.txt","a") as file01:
file01.write("Number of char pitchnarrate1: " + str(no_of_char) + "\n")
print("characater lenght ",no_of_char)
if no_of_char != 0:
if no_of_char == 1:
print("no_of_char == 1")
return render(
request,
"Pitchdeck/Pitchnarrate2.html",
{
"script": filename[:-5],
"character_list": char_list1,
"firstcharacter": newlist[0],
"numberofcharacter": len(char_list1),
"five_character": newlist,
"cd": centralDatabase.objects.get(user_id=request.user),
"numPages": numPages,
"user_name": request.user.username,
"user_email": request.user.email,
"services_use": services_use,
"services_len": len(services_use),
# "script_database": script_database
},
)
else:
print("no_of_char, else",)
return render(
request,
"Pitchdeck/Pitchnarrate2.html",
{
"script": filename[:-5],
"character_list": char_list1,
"numberofcharacter": len(char_list1),
"firstcharacter": newlist[0],
"secondcharacter": newlist[1],
"five_character": newlist,
"cd": centralDatabase.objects.get(user_id=request.user),
"numPages": numPages,
"user_name": request.user.username,
"user_email": request.user.email,
"services_use": services_use,
"services_len": len(services_use),
# "script_database": script_database
},
)
else:
error = "Sorry something went wrong while fetching The characters from script"
return render(request, "Pitchdeck/Pitchnarrate1.html", {"error": error})
print("Return to page one")
return render(request,"Pitchdeck/Pitchnarrate1.html",{"context":number})
@login_required(login_url="/")
def Pitchnarrate2(request):
# number = ReferUser.objects.filter(refferedy=request.user).count()
print("Delhi India****************************************: 2")
print(request.session)
print(request.session.items())
MNFScriptDatabase1 = {}
if request.method == "GET":
print("Delhigetting")
if request.method == "POST":
l = request.session["saved_characters_list"]
print(f"saved characters: {l}")
y = MNFScriptDatabase()
y.script_id = "scr_" + str(int(time.time()))
blockchainscript_id = int(time.time())
request.session["blockchainscript_id"]=blockchainscript_id
print("we are printing script id",y.script_id)
y.connecting_id = ""
connecting_id = ""
# y.author_name = request.POST.get('author_name')
y.script_title = request.POST.get("scriptname")
script_title = request.POST.get("scriptname")
url = request.session.get("script_url")
script_filename = request.session["script_name"] # get the filename
y.document_name = script_filename # save the filename
document_name = script_filename
print(script_filename)
script_page_count = countPages(
url, (((script_filename.split("/"))[-1]).split("."))[0] + ".pdf"
) # get the page count
print("neha1155op")
print(script_page_count)
y.numPages = script_page_count # save the page count
# y.script_title = request.POST['script_title']
numPages = script_page_count
y.script_file_path = url
script_file_path = url
y.actionline_language = request.session["non_dial_src_lang"]
actionline_language = request.session["non_dial_src_lang"]
y.actionline_script_language = request.session["non_dial_src_script"]
actionline_script_language = request.session["non_dial_src_script"]
y.dialogues_script_language = request.session["dial_src_script"]
dialogues_script_language = request.session["dial_src_script"]
y.dialogues_language = request.session["dial_src_lang"]
dialogues_language = request.session["dial_src_lang"]
request.session["line_by_line_narration"] = request.POST.get(
"line_by_line_narration"
)
request.session["character_introduction"] = request.POST.get(
"character_introduction"
)
request.session["screenplay_analysis"] = request.POST.get(
"screenplay_analysis")
request.session["one_pager"] = request.POST.get("one_pager")
request.session["elevator_pitch"] = request.POST.get("elevator_pitch")
request.session["character_narration"] = request.POST.get(
"character_narration")
print(request.session["character_narration"])
print(request.session["line_by_line_narration"])
print(request.session["screenplay_analysis"])
print(request.session["one_pager"])
print(request.session["elevator_pitch"])
service_use = []
if request.session["line_by_line_narration"] == "Line by Line Narration(Video)":
print(request.session["line_by_line_narration"])
with open("/home/user/mnf/project/MNF/Pitchdeck/error_check.txt","a") as file01:
file01.write("Line by Line narration: " + str(request.session["line_by_line_narration"]) + "\n")
y.linebyline = "True"
MNFScriptDatabase1["linebyline"] = "True"
service_use.append("Line by Line Narration")
if request.session["character_introduction"] == "Character Introduction(Video)":
print(request.session["character_introduction"])
with open("/home/user/mnf/project/MNF/Pitchdeck/error_check.txt","a") as file01:
file01.write("Character introduction: " + str(request.session["character_introduction"]) + "\n")
y.character_intro = "True"
MNFScriptDatabase1["character_intro"] = "True"
service_use.append("Character Introduction")
if request.session["screenplay_analysis"] == "Screenplay Analysis(Video)":
print(request.session["screenplay_analysis"])
with open("/home/user/mnf/project/MNF/Pitchdeck/error_check.txt","a") as file01:
file01.write("Screenplay analysis: " + str(request.session["screenplay_analysis"]) + "\n")
y.screenplay_analysis = "True"
MNFScriptDatabase1["screenplay_analysis"] = "True"
service_use.append("Screenplay Analysis")
if request.session["elevator_pitch"] == "Elevator Pitch(Video)":
print(request.session["elevator_pitch"])
with open("/home/user/mnf/project/MNF/Pitchdeck/error_check.txt","a") as file01:
file01.write("Elevator Pitch: " + str(request.session["elevator_pitch"]) + "\n")
y.elevator_pitch = "True"
MNFScriptDatabase1["elevator_pitch"] = "True"
service_use.append("Elevator Pitch")
if request.session["one_pager"] == "One Pager(PDF)":
print(request.session["one_pager"])
with open("/home/user/mnf/project/MNF/Pitchdeck/error_check.txt","a") as file01:
file01.write("One pager: " + str(request.session["one_pager"]) + "\n")
y.onepager = "True"
MNFScriptDatabase1["one_pager"] = "True"
service_use.append("One Pager")
if request.session["character_narration"] == "Characterwise Narration(Video)":
print(request.session["character_narration"])
with open("/home/user/mnf/project/MNF/Pitchdeck/error_check.txt","a") as file01:
file01.write("Character narration: " + str(request.session["character_narration"]) + "\n")
y.characterwise_narration = "True"
MNFScriptDatabase1["characterwise_narration"] = "True"
service_use.append("Characterwise Narration")
y.user_id = request.user
user_id = request.user
# print("userid session")
# y.progress = 10
request.session["service_use"]=len(service_use)
y.save()
MNFScriptDatabase1["user_id_id"] = str(user_id)
MNFScriptDatabase1["blockchainscript_id"] = blockchainscript_id
MNFScriptDatabase1["script_title"] = script_title
MNFScriptDatabase1["script_filename"]= script_filename
MNFScriptDatabase1["actionline_language"] = actionline_language
MNFScriptDatabase1["actionline_script_language"] = actionline_script_language
MNFScriptDatabase1["dialogues_language"] = dialogues_language
MNFScriptDatabase1["dialogues_script_language"] = dialogues_script_language
MNFScriptDatabase1["document_name"] = document_name
MNFScriptDatabase1["script_file_path"] = script_file_path
MNFScriptDatabase1["original_script_file_hash"] = request.session["original_script_file_hash"]
# xx = PitchVectorMultiAuthor()
pitchvector1={}
x = PitchVector()
x.choosescript = request.session["script_name"]
x.scriptDetails = y
x.script_id = y.script_id
x.scriptname = y.script
scriptname = y.script
x.genre = request.POST.get("genre")
genre = request.POST.get("genre")
x.subGenre = request.POST.get("subgenre")
subGenre = request.POST.get("subgenre")
x.projecttype = request.POST.get("projecttype")
projecttype = request.POST.get("projecttype")
x.noepisodes = request.POST.get("nepisode")
noepisodes = request.POST.get("nepisode")
x.eachepisodes = request.POST.get("eachepisode")
eachepisodes = request.POST.get("eachepisode")
x.other = request.POST.get("other")
other = request.POST.get("other")
x.language = request.POST.get("language")
language = request.POST.get("language")
x.dialect_language = request.POST.get(
"dialect_language") # ---------changes
dialect_language = request.POST.get(
"dialect_language")
x.platformproposed = request.POST.get("proposed")
platformproposed = request.POST.get("proposed")
x.country = request.POST.get("country")
country = request.POST.get("country")
x.countryCode = request.POST.get("code")
countryCode = request.POST.get("code")
x.state = request.POST.get("state")
state = request.POST.get("state")
x.city = request.POST.get("city")
city = request.POST.get("city")
x.languagebelt = request.POST.get("langugebelt")
languagebelt = request.POST.get("langugebelt")
x.target_audience = request.POST.get("target")
target_audience = request.POST.get("target")
x.target_field = request.POST.get("field")
target_field = request.POST.get("field")
x.timeperiod = request.POST.get("period")
timeperiod = request.POST.get("period")
x.geography = request.POST.get("geography")
geography = request.POST.get("geography")
x.dialogue_reference = request.POST.get("dialogue")
dialogue_reference = request.POST.get("dialogue")
x.premise = request.POST.get("premise")
premise = request.POST.get("premise")
x.logline = request.POST.get("logline")
logline = request.POST.get("logline")
x.save()
# y.progress = 20
# y.save()
# manoj - store data to central database
cd = centralDatabase.objects.get(user_id=request.user)
cd.country = x.country
cd.state = x.state
cd.city = x.city
cd.project_type = x.projecttype
cd.genre = x.genre
cd.subgenre = x.subGenre
cd.language = x.language
cd.set_in_time = x.timeperiod
cd.set_in_geography = x.geography
cd.logline = x.logline
with open("/home/user/mnf/project/MNF/Pitchdeck/error_check.txt","a") as file01:
file01.write("disct "+ str(pitchvector1)+ "\n")
# #CharacterWise Narration
print(request.POST.getlist("`character_check`"))
if request.POST.get("characterwise"):
selected_characters = request.POST.getlist("character_check")
# replace " " with "_" as uncove docx to pdf conversion was given error
# for i in range(len(selected_characters)):
# if " " in selected_characters[i]:
# selected_characters[i] = selected_characters[i].replace(" ","_")
x.set_selected_characters(selected_characters)
y.set_selected_characters(selected_characters)
print(
f"selected characters: {x.get_selected_characters()} type: {type(x.get_selected_characters())}"
)
# # Author details
if request.POST.get("author"):
# authorss = []
# # xx.script_id = y.script_id
# # xx.save()
# print("request.POST.getlist('name')",request.POST.getlist('name'))
# print("request.POST.getlist('auth_name')",request.POST.getlist('auth_name'))
# print("request.POST.getlist('auth_name') len", len(request.POST.getlist('auth_name')))
# print("request.FILES.getlist('uploadimage1')[i]",request.FILES.getlist('uploadimage1'))
# zips = zip_longest(request.POST.getlist('name'), request.POST.getlist('email'),request.POST.getlist('number'),request.POST.getlist('link'),request.FILES.getlist('uploadimage1'),request.POST.getlist('about'))
# print("::::::::::::::zip:::::::::::",set(zips))
# # for i in range(len(request.POST.getlist('name'))):
# # author = {
# # 'name': request.POST.getlist('name')[i],
# # 'email': request.POST.getlist('email')[i],
# # 'phone': request.POST.getlist('number')[i],
# # 'link': request.POST.getlist('link')[i],
# # 'image': request.FILES.getlist('uploadimage1')[i],
# # 'about': request.POST.getlist('about')[i],
# # }
# # authorss.append(author)
# for name, email, number, link, img, about in zip_longest(request.POST.getlist('name'), request.POST.getlist('email'),request.POST.getlist('number'),request.POST.getlist('link'),request.FILES.getlist('uploadimage1'),request.POST.getlist('about')):
# author = {
# 'name': name,
# 'email': email,
# 'phone': number,
# 'link': link,
# 'image': img,
# 'about': about,
# }
# authorss.append(author)
# # name_obj = Name.objects.create(name=name)
# # xx.names.add(name_obj)
# # xx.save()
# print("::::::::::::::::::--> authorss <--::::::::::::::::::",authorss)
# # l = request.FILES.getlist('uploadimage')[5]
# # lst = global_database.DB['mnfapp_pitchvector']
x.author = True
author = True
x.name = request.POST.get("auth_name")
name = request.POST.get("auth_name")
y.author_name = request.POST.get("auth_name")
author_name = request.POST.get("auth_name")
y.save()
x.author_profile = request.FILES.get("uploadimage")
x.author_email = request.POST.get("email")
x.phonenumber = request.POST.get("number")
x.author_about = request.POST.get("about")
x.author_link = request.POST.get("link")
x.save()
# Blockchain Data
MNFScriptDatabase1["author_name"] = author_name
# central database
cd.about = x.author_about
x.author1 = [
x.author_profile,
request.POST.get("auth_name"),
request.POST.get("about"),
request.POST.get("number"),
request.POST.get("email"),
request.POST.get("link"),
]
auth_name = request.POST.get("auth_name")
# store session variable
request.session["author_name"] = auth_name
auth_img = request.FILES.get("uploadimage")
auth_email = request.POST.get("email")
auth_phone = request.POST.get("number")
auth_about = request.POST.get("about")
auth_link = request.POST.get("link")
print(
auth_email,
auth_about,
auth_img,
auth_link,
auth_name,
auth_phone,
"====================Author Details Here===========================",
)
created_author = Author.objects.create(
author_profile=auth_img,
name=auth_name,
author_about=auth_about,
author_email=auth_email,
phonenumber=auth_phone,
author_link=auth_link,
)
# if auth_img:
# created_author.author_profile = request.FILES.get("uploadimage")
# created_author.save()
x.author_details.add(created_author)
print(created_author, "000000000000000000000000000000000")
x.save()
# # Plot and story flow
if request.POST.get("plot_story_flow"):
x.plot_story_flow = True
plot_story_flow = True
x.protagonist = request.POST.get("protagonist")
x.barrier = request.POST.get("barrier")
x.midpoint = request.POST.get("midpoint")
x.climax = request.POST.get("climax")
x.conflictresolved = request.POST.get("resolved")
x.minute_protogonist = request.POST.get("minute_pro")
x.conflict_reaches_climax = request.POST.get("conflict")
x.save()
# Blockchain
# # About shooting
if request.POST.get("shooting"):
x.shooting = True
x.special_preperation = request.POST.get("specialpre")
x.days_shoot_required = request.POST.get("shoot")
x.percentage_location = request.POST.get("location")
x.percentage_scene = request.POST.get(
"scene"
) # percentage of scenes having stunts
percentage_scene = request.POST.get(
"scene"
)
x.major_prosthetic = request.POST.get("major")
x.during_production = request.POST.get("during_pro")
x.save()
# Dream cast & Locations
if request.POST.get("dream_cast_locations"):
x.dream_cast_locations = True
dream_cast_locations = True
x.upload_image1 = request.FILES.get("uploadimage1")
upload_image1 = request.FILES.get("uploadimage1")
x.leadcharacter = [
request.POST.get("leadcharacter"),
request.POST.get("proposedactor1"),
x.upload_image1,
]
leadcharacter = [
request.POST.get("leadcharacter"),
request.POST.get("proposedactor1"),
upload_image1,
]
# x.leadcharacter = request.POST.get('leadcharacter')
# x.proposedactor1 = request.POST.get('proposedactor1')
x.upload_image2 = request.FILES.get("uploadimage2")
upload_image2 = request.FILES.get("uploadimage2")
x.secondleadcharacter = [
request.POST.get("secondleadcharacter"),
request.POST.get("proposedactor2"),
x.upload_image2,
]
secondleadcharacter = [
request.POST.get("secondleadcharacter"),
request.POST.get("proposedactor2"),
upload_image2,
]
# x.secondleadcharacter = request.POST.get('secondleadcharacter')
# x.proposedactor2 = request.POST.get('proposedactor2')
x.upload_image3 = request.FILES.get("uploadimage3")
upload_image3 = request.FILES.get("uploadimage3")
x.mainvillan = [
request.POST.get("mainvillan"),
request.POST.get("proposedactor3"),
x.upload_image3,
]
mainvillan = [
request.POST.get("mainvillan"),
request.POST.get("proposedactor3"),
upload_image3,
]
# x.mainvillan = request.POST.get('mainvillan')
# x.proposedactor3 = request.POST.get('proposedactor3')
x.upload_image4 = request.FILES.get("uploadimage4")
upload_image4 = request.FILES.get("uploadimage4")
x.associatecharacter = [
request.POST.get("associatecharacter"),
request.POST.get("proposedactor4"),
x.upload_image4,
]
associatecharacter = [
request.POST.get("associatecharacter"),
request.POST.get("proposedactor4"),
upload_image4,
]
# x.proposedactor4 = request.POST.get('proposedactor4')
x.upload_image5 = request.FILES.get("uploadimage5")
upload_image5 = request.FILES.get("uploadimage5")
x.associatevillan = [
request.POST.get("associatevillan"),
request.POST.get("proposedactor5"),
x.upload_image5,
]
associatevillan = [
request.POST.get("associatevillan"),
request.POST.get("proposedactor5"),
upload_image5,
]
# x.proposedactor5 = request.POST.get('proposedactor5')
x.upload_image6 = request.FILES.get("uploadimage6")
upload_image6 = request.FILES.get("uploadimage6")
x.firstlocation = [
request.POST.get("firstlocation"),
request.POST.get("proposedactor6"),
x.upload_image6,
]
firstlocation = [
request.POST.get("firstlocation"),
request.POST.get("proposedactor6"),
upload_image6,
]
x.upload_image7 = request.FILES.get("uploadimage7")
upload_image7 = request.FILES.get("uploadimage7")
x.secondlocation = [
request.POST.get("secondlocation"),
request.POST.get("proposedactor7"),
x.upload_image7,
]
secondlocation = [
request.POST.get("secondlocation"),
request.POST.get("proposedactor7"),
upload_image7,
]
# Pager_function
# x.proposedactor7 = request.POST.get('proposedactor7')
x.upload_image8 = request.FILES.get("uploadimage8")
upload_image8 = request.FILES.get("uploadimage8")
x.thirdlocation = [
request.POST.get("thirdlocation"),
request.POST.get("proposedactor8"),
x.upload_image8,
]
if request.session["character_introduction"] == "Character Introduction(Video)":
extraCharData = []
for charName, purposeActor, image in zip_longest(request.POST.getlist('character_list'), request.POST.getlist('proposed_actor_list'),request.FILES.getlist('upload_image_list')):
charData = {
"name": charName,
"purpose_actor": purposeActor,
"image": str(image)
}
extraCharData.append(charData)
print("$$$$$$$$$$$$$$______extraCharData______$$$$$$$$$$$$$$", extraCharData)
x.upload_image6 = str(extraCharData)
upload_image6 = str(extraCharData)
pitchvector1["upload_image6 "]=upload_image6
x.save()
# x.proposedactor8 = request.POST.get('proposedactor8')
x.save()
# # About Film budget
if request.POST.get("film_budget"):
x.film_budget = True
film_budget = True
# x.making_expenses = request.POST.get("expense")
x.percentage_scenes_required = request.POST.get("percentage_vfx")
# x.vfx_expenses = request.POST.get("vfx")
x.approx_budget_required = request.POST.get("approx_budget")
# ---------------------changes by neha 18/03/23
# x.making_expenses_currency = request.POST.get("projectbudget1")
# x.vfx_expenses_currency = request.POST.get("projectbudget2")
x.approx_budget_currency = request.POST.get("projectbudget3")
# --------end
x.save()
# cd.budget_amount = x.approx_budget_required
# # Strengths & Expectations
if request.POST.get("strengths_and_expectation"):
x.strengths_and_expectation = True
x.script_succed = request.POST.get("succed")
x.produced_now = request.POST.get("produce_now")
x.monetary_non_monetary_expectation = request.POST.get(
"expectations")
x.save()
cd.save()
# return render(request,"Pitchdeck/PitchnarratedVideos.html",{"script_id": y.script_id,"script_file_path": "","restrict_to_five": "Yes",},) # altered line
# -----BY HARSH
# try:
# membertype = privilegedUser1.objects.get(
# user=request.user, is_active="yes"
# ).memberType
# except:
# messages.error(request, "You are not a privileged member.")
# return render(request, "Pitchdeck/Pitchnarrate1.html")
request.session["script_id"] = y.script_id
script_id=request.session["script_id"]
request.session["numPages"] = y.numPages
request.session["actionline_language"] = y.actionline_language
request.session["actionline_script_language"] = y.actionline_script_language
request.session["dialogues_language"] = y.dialogues_language
request.session["dialogues_script_language"] = y.dialogues_script_language
request.session["languages"] = [
y.actionline_language, y.dialogues_language]
request.session["document_name"] = y.document_name
request.session["script_title"] = y.script_title
request.session["script_file_path"] = y.script_file_path
context = {
"script_id": y.script_id,
"script_file_path": y.script_file_path,
}
context["restrict_to_five"] = "yes"
context["numPages"] = y.numPages
context['script_title'] = y.script_title
context["ndial_src"] = y.actionline_language
context["dial_src"] = y.dialogues_language
context["ndial_script"] = y.actionline_script_language
context["dial_script"] = y.dialogues_script_language
# y.progress = 40
y.save()
# Blockchain code by Asha..
request.session["pitchvector1"] = str(pitchvector1)
request.session["MNFScriptDatabase1"] = str(MNFScriptDatabase1)
# :::::::::::::
# x = User.objects.get(id=request.user)
# id = x.id
id = request.user.id
num_pages = request.session["numPages"]
print("did lil chanps1", num_pages)
# ---------------------------------------changes
if num_pages > 5:
# check user is priviledged member or not
if not privilegedUser1.objects.filter(user=request.user,is_active="yes").exists():
with open("/home/user/mnf/project/MNF/Pitchdeck/error_check.txt","a") as file01:
file01.write("Not a privilage user"+ str(privilegedUser1.objects.filter(user=request.user,is_active="yes"))+ "\n")
context["membershipNarration"] = int(settings.MONTHLY_MEMBER)
request.session["UpdatePriviledgedUser"] = True
# try:
# 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
# )
# except:
# pass
pricelist = NarrationPricing(y.script_id, l, id)
print("pricelist in pre",pricelist)
with open("/home/user/mnf/project/MNF/Pitchdeck/error_check.txt","a") as file01:
file01.write("4."+ str(pricelist)+ "\n")
request.session["total_amount"] = pricelist["total_amount"]
context["total_amount"] = pricelist["total_amount"]
context["amount_charged"] = pricelist["amount_charged"] + int(settings.MONTHLY_MEMBER)
request.session["amount_charged"] = pricelist["amount_charged"] + int(settings.MONTHLY_MEMBER)
# context["discount"] = context["total_amount"] + context["membershipNarration"] - context["amount_charged"]
# request.session["discount"]=round(context["discount"], 2)
# context["discount"] = request.session["discount"]
pdiscount= 0
context["pdiscount"] = pdiscount
context["sdiscount"] = pricelist["sdiscount"]
with open("/home/user/mnf/project/MNF/Pitchdeck/error_check.txt","a") as file01:
file01.write("5.stafff discount-------------------" + str(context["sdiscount"]) + "\n")
if pricelist["sdiscount"]==0:
context["staff_discount_calculate"] = 0
else:
staff_discount_calculate = float((pricelist["sdiscount"] / 100) * pricelist["total_amount"])
context["staff_discount_calculate"] = staff_discount_calculate
p_discount_calculate = float((context["total_amount"]-context["staff_discount_calculate"])*pricelist["pdiscount"] / 100)
context["p_discount_calculate"] = p_discount_calculate
context["rdiscount"] = pricelist["rdiscount"]
running_discount_calculate = float((context["total_amount"]-context["staff_discount_calculate"]-context["p_discount_calculate"])*context["rdiscount"]/ 100)
context["running_discount_calculate"] = running_discount_calculate
context["imdiscount"] = pricelist["imdiscount"]
im_discount_calculate = float((context["total_amount"]-context["staff_discount_calculate"]-context["p_discount_calculate"]-context["running_discount_calculate"])*pricelist["imdiscount"]/ 100)
context["im_discount_calculate"] =round(im_discount_calculate,2)
with open("/home/user/mnf/project/MNF/Pitchdeck/error_check.txt","a") as file01:
file01.write("5.student discount-------------------" + str(context["im_discount_calculate"]) + "\n")
# context["discount"] = context["total_amount"] - \
# context["amount_charged"]
# context["discount"]= context["amount_charged"]+ context["p_discount_calculate"]+ context["staff_discount_calculate"]+ context["running_discount_calculate"]+ context["im_discount_calculate"]
context["discount"] = float(context["staff_discount_calculate"]+context["p_discount_calculate"]+context["running_discount_calculate"]+context["im_discount_calculate"])
request.session["discount"]=round(context["discount"], 2)
context["discount"] = request.session["discount"]
print("did lil chanps0")
try:
wall = Wallet.objects.get(user=request.user)
context["balance"] = wall.balance
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
print("did lil chanps2")
request.session["pages_greater_than_five"] = "true"
indent_context = create_indent(request,"Pitchdeck",script_id,len(service_use), "",pricelist["total_amount"], pricelist["amount_charged"],context["discount"])
request.session["indent_context"] = indent_context
return render(request, "Pitchdeck/narration_checkoutnew.html", context)
else:
request.session["UpdatePriviledgedUser"] = False
pricelist = NarrationPricing(y.script_id, l, id) # changes done by manoj
print("pricelist in post",pricelist)
with open("/home/user/mnf/project/MNF/Pitchdeck/error_check.txt","a") as file01:
file01.write("5." + str(pricelist) + "\n")
request.session["total_amount"] = pricelist["total_amount"]
context["total_amount"] = pricelist["total_amount"]
context["membershipNarration"] = 0
context["amount_charged"] = pricelist["amount_charged"]
request.session["amount_charged"] = pricelist["amount_charged"]
context["pdiscount"] = pricelist["pdiscount"]
context["sdiscount"] = pricelist["sdiscount"]
with open("/home/user/mnf/project/MNF/Pitchdeck/error_check.txt","a") as file01:
file01.write("5.stafff discount-------------------" + str(context["sdiscount"]) + "\n")
if pricelist["sdiscount"]==0:
context["staff_discount_calculate"] = 0
else:
staff_discount_calculate = float((pricelist["sdiscount"] / 100) * pricelist["total_amount"])
context["staff_discount_calculate"] = staff_discount_calculate
p_discount_calculate = float((context["total_amount"]-context["staff_discount_calculate"])*pricelist["pdiscount"] / 100)
context["p_discount_calculate"] = p_discount_calculate
context["rdiscount"] = pricelist["rdiscount"]
running_discount_calculate = float((context["total_amount"]-context["staff_discount_calculate"]-context["p_discount_calculate"])*context["rdiscount"]/ 100)
context["running_discount_calculate"] = running_discount_calculate
context["imdiscount"] = pricelist["imdiscount"]
im_discount_calculate = float((context["total_amount"]-context["staff_discount_calculate"]-context["p_discount_calculate"]-context["running_discount_calculate"])*pricelist["imdiscount"]/ 100)
context["im_discount_calculate"] =round(im_discount_calculate,2)
with open("/home/user/mnf/project/MNF/Pitchdeck/error_check.txt","a") as file01:
file01.write("5.student discount-------------------" + str(context["im_discount_calculate"]) + "\n")
# context["discount"] = context["total_amount"] - \
# context["amount_charged"]
# context["discount"]= context["amount_charged"]+ context["p_discount_calculate"]+ context["staff_discount_calculate"]+ context["running_discount_calculate"]+ context["im_discount_calculate"]
context["discount"] = float(context["staff_discount_calculate"]+context["p_discount_calculate"]+context["running_discount_calculate"]+context["im_discount_calculate"])
request.session["discount"]=round(context["discount"], 2)
context["discount"] = request.session["discount"]
try:
wall = Wallet.objects.get(user=request.user)
context["balance"] = wall.balance
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
print("did lil chanps2")
request.session["pages_greater_than_five"] = "true"
indent_context = create_indent(request,"Pitchdeck",script_id,len(service_use), "",pricelist["total_amount"], pricelist["amount_charged"],context["discount"])
request.session["indent_context"] = indent_context
return render(request, "Pitchdeck/narration_checkoutnew.html", context)
else:
print("did lil chanps3")
request.session["pages_greater_than_five"] = "false"
context = {
"script_id": request.session["script_id"],
"script_file_path": request.session["script_file_path"],
"restrict_to_five": "no",
"servies_user":service_use,
"servies_user_length" : len(service_use),
}
return render(request, "Pitchdeck/PitchnarratedVideos.html", context)
# ---------------------------------end change
return render(
request,
"Pitchdeck/Pitchnarrate2.html",
{"cd": centralDatabase.objects.get(user_id=request.user)},
)
def NarrationPricing(script_id, l, u):
script_info = MNFScriptDatabase.objects.get(script_id=script_id)
vector_info = PitchVector.objects.get(script_id=script_id)
numPages = script_info.numPages
amt_linebyline = 0
amt_character_intro = 0
amt_screenplay_analysis = 0
amt_elevator_pitch = 0
amt_onepager = 0
amt_characterwise_narration = 0
if script_info.linebyline == "True":
amt_linebyline = settings.LINE_BY_LINE * numPages
if script_info.onepager == "True":
# amt_onepager = settings.ONE_PAGER
if numPages > 0 and numPages <= 15:
amt_onepager = settings.ONE_PAGER1
if numPages >= 16 and numPages <= 50:
amt_onepager = settings.ONE_PAGER2
if numPages >= 51 and numPages <= 100:
amt_onepager = settings.ONE_PAGER3
if numPages > 100:
amt_onepager = settings.ONE_PAGER4
if script_info.elevator_pitch == "True":
# amt_elevator_pitch = settings.ELEVATOR_PITCH
if numPages > 0 and numPages <= 15:
amt_elevator_pitch = settings.ELEVATOR_PITCH1
if numPages >= 16 and numPages <= 50:
amt_elevator_pitch = settings.ELEVATOR_PITCH2
if numPages >= 51 and numPages <= 100:
amt_elevator_pitch = settings.ELEVATOR_PITCH3
if numPages > 100:
amt_elevator_pitch = settings.ELEVATOR_PITCH4
if script_info.screenplay_analysis == "True":
if numPages > 0 and numPages <= 15:
amt_screenplay_analysis = settings.SCREENPLAY_ANALYSIS1
if numPages >= 16 and numPages <= 50:
amt_screenplay_analysis = settings.SCREENPLAY_ANALYSIS2
if numPages >= 51 and numPages <= 100:
amt_screenplay_analysis = settings.SCREENPLAY_ANALYSIS3
if numPages > 100:
amt_screenplay_analysis = settings.SCREENPLAY_ANALYSIS4
if script_info.character_intro == "True":
# amt_character_intro = len(l) * settings.CHARACTER_INTRODUCTION
if numPages > 0 and numPages <= 15:
amt_character_intro = settings.CHARACTER_INTRODUCTION1
if numPages >= 16 and numPages <= 50:
amt_character_intro = settings.CHARACTER_INTRODUCTION2
if numPages >= 51 and numPages <= 100:
amt_character_intro = settings.CHARACTER_INTRODUCTION3
if numPages > 100:
amt_character_intro = settings.CHARACTER_INTRODUCTION4
if script_info.characterwise_narration == "True":
# selected_character = vector_info.selected_characters
# selected_character = json.loads(selected_character)
# amt_characterwise_narration = (
# len(selected_character) * settings.CHARACTERWISE_NARATION
# )
amt_characterwise_narration = settings.CHARACTERWISE_NARATION * numPages
total_amount = (
amt_linebyline
+ amt_onepager
+ amt_elevator_pitch
+ amt_screenplay_analysis
+ amt_character_intro
+ amt_characterwise_narration
)
amount_charged = total_amount
# ----To calculate if package discount is available
if (
script_info.linebyline == "True"
and script_info.onepager == "True"
and script_info.elevator_pitch == "True"
and script_info.screenplay_analysis == "True"
and script_info.character_intro == "True"
and script_info.characterwise_narration == "True"
):
amount_charged = total_amount - (
total_amount * settings.COMPLETE_PITCHDECK / 100
)
if (
script_info.linebyline != "True"
and script_info.onepager == "True"
and script_info.elevator_pitch == "True"
and script_info.screenplay_analysis != "True"
and script_info.character_intro != "True"
and script_info.characterwise_narration != "True"
):
amount_charged = total_amount - (
total_amount * settings.ONEPAGER_ELEVATORPITCH / 100
)
if (
script_info.linebyline != "True"
and script_info.onepager != "True"
and script_info.elevator_pitch != "True"
and script_info.screenplay_analysis == "True"
and script_info.character_intro == "True"
and script_info.characterwise_narration != "True"
):
amount_charged = total_amount - (
total_amount * settings.SCREENPLAY_CHARACTERINTRO / 100
)
if (
script_info.linebyline == "True"
and script_info.onepager != "True"
and script_info.elevator_pitch != "True"
and script_info.screenplay_analysis == "True"
and script_info.character_intro == "True"
and script_info.characterwise_narration != "True"
):
amount_charged = total_amount - (
total_amount * settings.LBL_SCREENPLAY_CHARACTERINTRO / 100
)
pricelist = {
"total_amount": total_amount,
"amt_linebyline": amt_linebyline,
"amt_character_intro": amt_character_intro,
"amt_screenplay_analysis": amt_screenplay_analysis,
"amt_elevator_pitch": amt_elevator_pitch,
"amt_onepager": amt_onepager,
"amt_characterwise_narration": amt_characterwise_narration,
"pdiscount":int(0),
}
# ------To calculate priviledge discount
user = User.objects.get(id=u)
# manoj updated code for priviledged user
try:
memberType = privilegedUser1.objects.filter(user=user, is_active="yes") # changes done by manoj
if memberType:
memberType = memberType.first().memberType
if memberType == "normal":
pricelist["pdiscount"] = 0
elif memberType == "yearly":
pricelist["pdiscount"] = settings.YEARLY_MEMBER_ADDITIONAL
amount_charged = amount_charged - (
settings.YEARLY_MEMBER_ADDITIONAL * amount_charged / 100
)
elif memberType == "Life Member":
pricelist["pdiscount"] = settings.LIFE_MEMBER_ADDITIONAL
amount_charged = amount_charged - (
settings.LIFE_MEMBER_ADDITIONAL * amount_charged / 100
)
except:
pricelist["pdiscount"] = 0
pricelist["sdiscount"] = 0
if User.objects.get(id=u).is_staff: # changes done by manoj
pricelist["sdiscount"] = settings.EMPLOY_DISCOUNT
amount_charged = amount_charged - (
settings.EMPLOY_DISCOUNT * amount_charged / 100
)
pricelist["rdiscount"] = settings.RUNNING_DISCOUNT_PITCHDECK
amount_charged = amount_charged - (
settings.RUNNING_DISCOUNT_PITCHDECK * amount_charged / 100
)
pricelist["imdiscount"] = 0
# changes done by manoj
if Institutional_user.objects.filter(user=user, status="verified").exists():
pricelist["imdiscount"] = settings.IM_DISCOUNT
amount_charged = amount_charged - \
(settings.IM_DISCOUNT * amount_charged / 100)
pricelist["amount_charged"] = float(round(amount_charged, 2))
return pricelist
# @csrf_exempt
# @require_GET
# def Pitch_creation(request):
# reset_progress_dict(userId=request.user.id)
# script_id = request.GET["script_id"]
# from pymongo import MongoClient
# # MongoDBUrl = "mongodb+srv://mynextfilm:mnf123@cluster0.ojasb.mongodb.net/myFirstDatabase?retryWrites=true&w=majority"
# client = MongoClient(MongoDBUrl)
# db = client.DB
# ScriptDatabase = "mnfapp_mnfscriptdatabase"
# script_info = db[ScriptDatabase].find_one({"script_id": script_id})
# script_file_path = script_info.get("script_file_path")
# # try:
# data_for_blockchain = []
# data_for_blockchain.append(script_file_path)
# # raise ValueError #-----to test for payment refund commentout
# update_progress(userId=request.user.id, progress=30)
# try:
# print("vector started in pitchcretatio")
# vector_generation.vector_gen(script_file_path, script_id)
# print("Vectors generated succesfully")
# update_progress(userId=request.user.id, progress=50)
# except Exception as e:
# update_progress(userId=request.user.id, progress=0)
# time.sleep(20)
# delet_user_progress(userId=request.user.id)
# sys.exit(e)
# script_info = db[ScriptDatabase].find_one({"script_id": script_id})
# VectorDatabase = "mnfapp_pitchvector"
# vector_info = db[VectorDatabase].find_one({"script_id": script_id})
# # try:
# if script_info != None:
# # Code to convert docx to pdf
# """
# str1 = "unoconv -f pdf"
# str2 = script_info.get("script_file_path")
# str3 = str1 + " " + str2
# print("Filpath:", script_info.get("script_file_path"))
# os.system(str3)
# print("File converted")
# temp = script_info.get("script_file_path").split("/")
# temp = temp[-1].split(".")
# # print(rf"{basePath}/MNF/media/PdfFiles/{temp} + '.pdf'")
# """
# document_name = script_info["document_name"][0:-5]
# script_info[
# "script_file_pdf_path"
# ] = rf"{basePath}/media/PdfFiles/{document_name}.pdf"
# print("Pitch Creation", script_info)
# script_info["narration_video_path"] = ""
# script_info["line_by_line_narration_video_path"] = ""
# script_info["script_genre"] = ""
# # pdf = PdfFileReader(open(script_info.get("script_file_pdf_path"), "rb"))
# # number_of_pages = pdf.getNumPages()
# # print("No. of pages in PDF:", number_of_pages)
# # script_info["number_of_pages"] = int(number_of_pages)
# db[ScriptDatabase].save(script_info)
# else:
# print(" Entry for script id not found")
# # restrict = request.GET["restrict_to_five"]
# # narration_generation.narration_function(script_id, restrict)
# # narration_generation.narration_function(script_id)
# # linebyline_narration.line_by_line_narration(script_id) #changed 12th March
# print(
# "**************************************************************************************************************"
# )
# print(
# "******************************_______*************************************************************************"
# )
# # screenplay_main.screenplay_function(script_id)
# # pitch_function.pitch_function(script_id)
# print("________start here______")
# script_title = script_info.get("script_title")
# print("$$")
# if script_info["characterwise_narration"] == "True":
# """
# access selected_characters here from database
# run characterwise script generation function
# """
# try:
# print("________characterwise_narration______")
# selected_character = vector_info["selected_characters"]
# # selected_character = script_info["selected_characters"]
# input_dir = request.session.get("script_dir_url")
# input_filename = request.session["script_name"]
# selected_character = json.loads(
# selected_character) # json string to list
# dic_of_chr_path = mnf_ss.get_subset_character_script(
# input_dir, input_filename, selected_character
# )
# print("Out of Mohit Function")
# path_list = []
# # character_pagecount=[]
# for i in selected_character:
# print("Entering loop of character ,", i)
# c = MNFScriptDatabase()
# c.script_id = "scr_" + str(int(time.time()))
# # c.main_script_id = script_info["main"]
# print("script_info connecting_id",
# script_info["connecting_id"])
# # c.connecting_id = script_id
# c.connecting_id = script_info
# print("Printing Script id of first character", c.script_id)
# c.script_title = script_title + \
# "_" + str(i) # session variable
# url = dic_of_chr_path[i]
# pdfname = url.split("/")[-1][0:-5] + ".pdf"
# c.script_file_path = url
# str1 = "unoconv -f pdf"
# # str2 = script_info.get("script_file_path")
# # str2 = url.replace(" ","_")
# str2 = url
# str3 = str1 + " " + '"' + str2 + '"'
# print("Filpath:", url)
# os.system(str3)
# print("File converted")
# temp = url.split("/")
# # name.docx
# temp = temp[-1].split(".")
# # c.script_file_pdf_path = rf"{basePath}/media/PdfFiles/{temp[0]}"+ ".pdf"
# c.script_file_pdf_path = rf"{url[:-5]}" + ".pdf"
# print("printing script path", c.script_file_pdf_path)
# print("printing url", url)
# print(
# "************************",
# rf"{basePath}/media/PdfFiles/{temp[0]}" + ".pdf",
# )
# # pdf = PdfFileReader(open(rf"{basePath}/media/PdfFiles/{temp[0]}"+ ".pdf", "rb"))
# pdf = PdfFileReader(open(rf"{c.script_file_pdf_path}", "rb"))
# # number_of_pages = countPages(
# # url, pdfname) # get the page count
# print("1")
# number_of_pages = pdf.getNumPages()
# # character_pagecount.append(number_of_pages)
# print("1")
# c.numPages = number_of_pages
# # print("1")
# # c.script_file_path = url
# print("1")
# c.actionline_language = request.session["non_dial_src_lang"]
# print("1")
# c.actionline_script_language = request.session["non_dial_src_script"]
# print("1")
# c.dialogues_script_language = request.session["dial_src_script"]
# print("1")
# c.dialogues_language = request.session["dial_src_lang"]
# c.author_name = request.session["author_name"]
# print("1")
# # c.user_id = script_info["user_id_id"]
# # c.user_id = request.user
# print("1")
# c.save()
# print("Vector Creating for Character")
# print("script path", c.script_file_path)
# print("script id", c.script_id)
# vector_generation.vector_gen(c.script_file_path, c.script_id)
# print(f"Vector Created for {script_title}")
# # c.save()
# linebyline_narration.line_by_line_narration(
# c.script_id) # error here
# print("Characterwise Video Created")
# c.line_by_line_narration_video_path = (
# rf"{basePath}/media/videos/Narrated_Videos/{c.script_title}.webm"
# )
# # lst.append()
# path_list.append(
# rf"{basePath}/media/videos/Narrated_Videos/{c.script_title}.webm"
# )
# # exit()
# # script_info["character_pagecount"] = json.dumps(character_pagecount)
# script_info["characterwise_video_path"] = json.dumps(path_list)
# data_for_blockchain.append(json.dumps(path_list))
# db[ScriptDatabase].save(script_info)
# except Exception as e:
# update_progress(userId=request.user.id, progress=0)
# time.sleep(10)
# delet_user_progress(userId=request.user.id)
# sys.exit(e)
# # print("will this work",dic_of_chr_path)
# if script_info["onepager"] == "True":
# try:
# print("Before pager_function", script_id)
# Pager_function.pager_function(script_id)
# script_info[
# "onepager_pdf_path"
# ] = rf"{basePath}/media/Onepager/{script_title}.pdf"
# data_for_blockchain.append(
# rf"{basePath}/media/Onepager/{script_title}.pdf")
# db[ScriptDatabase].save(script_info)
# print("One Pager generated sucessfully")
# except Exception as e:
# update_progress(userId=request.user.id, progress=0)
# time.sleep(10)
# delet_user_progress(userId=request.user.id)
# sys.exit(e)
# if script_info["screenplay_analysis"] == "True":
# try:
# print("Rohit before")
# screenplay_main.screenplay_function(script_id)
# print("Rohit after")
# script_info[
# "screenplay_analysis_video_path"
# ] = rf"{basePath}/media/Screenplay/{script_title}_screenplay.webm"
# data_for_blockchain.append(
# rf"{basePath}/media/Screenplay/{script_title}_screenplay.webm"
# )
# db[ScriptDatabase].save(script_info)
# print("Screenplay generated sucessfully")
# except Exception as e:
# update_progress(userId=request.user.id, progress=0)
# time.sleep(10)
# delet_user_progress(userId=request.user.id)
# sys.exit(e)
# if script_info["elevator_pitch"] == "True":
# try:
# print("Entering ElevatorPitch: ")
# pitch_function.pitch_function(script_id)
# script_info["elevator_pitch_video_path"] = (
# rf"{basePath}/media/Pitch/" +
# str(script_title) + "_pitchdeck.webm"
# )
# data_for_blockchain.append(
# rf"{basePath}/media/Pitch/" +
# str(script_title) + "_pitchdeck.webm"
# )
# print("ElevatorPitch generated sucessfully")
# db[ScriptDatabase].save(script_info)
# print("Rohit2")
# except Exception as e:
# update_progress(userId=request.user.id, progress=0)
# time.sleep(10)
# delet_user_progress(userId=request.user.id)
# sys.exit(e)
# if script_info["character_intro"] == "True":
# try:
# print("----Entering character introduction-----")
# # obj = TestingC.Char_video_class(script_id)
# # characterdata = obj.char_data_written()
# # for i in characterdata:
# # obj.first_intro_page(i)
# Char_function.char_function(script_id)
# script_info["character_intro_video_path"] = rf'{basePath}/media/character_Intro/{str(script_title)}.webm'
# # # # data_for_blockchain.append(rf"{basePath}/media/Pitch/" + str(script_title) + "_pitchdeck.webm")
# print("character introduction generated sucessfully")
# db[ScriptDatabase].save(script_info)
# print("Rohit2")
# except Exception as e:
# update_progress(userId=request.user.id, progress=0)
# time.sleep(10)
# delet_user_progress(userId=request.user.id)
# sys.exit(e)
# if script_info["linebyline"] == "True":
# try:
# print("Rohit3")
# linebyline_narration.line_by_line_narration(script_id)
# print("Narration generated sucessfully")
# script_title = script_info.get("script_title")
# # script_info[
# # 'narration_video_path'] = rf"{basePath}/media/videos/Narrated_Videos/{script_title}.webm"
# script_info[
# "line_by_line_narration_video_path"
# ] = rf"{basePath}/media/videos/Narrated_Videos/{script_title}.webm"
# script_info["narration_video_path"] = script_info[
# "line_by_line_narration_video_path"
# ]
# except Exception as e:
# update_progress(userId=request.user.id, progress=0)
# time.sleep(10)
# delet_user_progress(userId=request.user.id)
# sys.exit(e)
# # data_for_blockchain.append(script_info["narration_video_path"])
# context = {
# "status": "Success",
# }
# user = request.user
# email = user.email
# # ------------------------------------------------------blockchain
# # script_path = str(rf"{basePath}/media/scripts/{script_title}")
# print("list ", data_for_blockchain)
# # data = [script_path, data_for_blockchain ]
# # print("All Files ",data)
# print("Function 11")
# update_progress(userId=request.user.id, progress=85)
# try:
# files, timestamp = upload_zipfile_to_ipfs(
# data_for_blockchain, str(script_title), "pitchdeck", email
# )
# script_info["timestamp"] = timestamp
# print("timestamp of blockchain", files, timestamp)
# script_info["uploaded_script_encoded"] = files
# # script_info["translated_script_encoded"] = files[1]
# db[ScriptDatabase].save(script_info)
# except Exception as e:
# update_progress(userId=request.user.id, progress=0)
# time.sleep(10)
# delet_user_progress(userId=request.user.id)
# sys.exit(e)
# # ---------------------------------------------------------------------------
# current_site = get_current_site(request)
# context = {
# "domain": current_site.domain,
# "serviceName": "Pitch Creation",
# "name": email,
# "amount": request.POST.get("total_amount"),
# # "timestamp":timestamp,
# # "key":script_title
# }
# num_pages = request.session["numPages"]
# if num_pages > 5: # ----------------neha
# request.session["pages_greater_than_five"] == "true"
# message = render_to_string("narration/MR31.html", context)
# text_content = strip_tags(message)
# msg = EmailMultiAlternatives(
# "Successfully Narrated",
# text_content,
# settings.EMAIL_HOST_USER,
# [email],
# )
# msg.attach_alternative(message, "text/html")
# msg.send()
# else:
# # send mail only for confirmation hjgjh
# request.session["pages_greater_than_five"] = "false" # --------neha
# message = render_to_string("narration/MR31.html", context)
# text_content = strip_tags(message)
# msg = EmailMultiAlternatives(
# "Successfully Narrated",
# text_content,
# settings.EMAIL_HOST_USER,
# [email],
# )
# msg.attach_alternative(message, "text/html")
# msg.send()
# del request.session["pages_greater_than_five"]
# var = Notifications(
# user_id=request.user,
# notification=str(
# "Narration generated successfully for " + script_title),
# )
# var.save()
# update_progress(userId=request.user.id, progress=100)
# time.sleep(10)
# delet_user_progress(userId=request.user.id)
# return JsonResponse(context)
def Pitch_creation(request):
reset_progress_dict(userId=request.user.id)
script_id = request.GET["script_id"]
from pymongo import MongoClient
# MongoDBUrl = "mongodb+srv://mynextfilm:mnf123@cluster0.ojasb.mongodb.net/myFirstDatabase?retryWrites=true&w=majority"
client = MongoClient(MongoDBUrl)
db = client.DB
ScriptDatabase = "mnfapp_mnfscriptdatabase"
script_info = db[ScriptDatabase].find_one({"script_id": script_id})
print(">>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>",script_info)
script_file_path = script_info.get("script_file_path")
print(">>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>",script_file_path)
data_for_blockchain = []
data_for_blockchain.append(script_file_path)
# raise ValueError #-----to test for payment refund commentout
update_progress(userId=request.user.id, progress=30)
with open("/home/user/mnf/project/MNF/Pitchdeck/error_check1.txt","a") as file01:
file01.write("6.INSIDE pitch_creation function : vector id is -->" + str(script_id)+ "\n")
#-----------------modified audit
script_id_audit = request.session["script_id_audit"]
check_status_and_trigger_vector(script_id_audit,script_id)
# audit_vector_integration_pitchdeck(script_id_audit,script_id)
print(":>:>:>complete")
# audit_vector_integration(script_file_path,script_id,request)
with open("/home/user/mnf/project/MNF/Pitchdeck/error_check1.txt","a") as file01:
file01.write("7.Vectors generated succesfully" + "\n")
# try:
# print("vector started in pitchcretatio")
# # from scriptAudit.views import generate_script_id
# # generate_script_id(script_file_path, request)
# print("vector:",script_id)
# # vector_generation.vector_gen(script_file_path, script_id)
# audit_vector_integration(script_file_path,script_id,request)
# print("vector:","Vectors generated succesfully")
# with open("/home/user/mnf/project/MNF/Pitchdeck/error_check.txt","w+") as file01:
# file01.write("Vectors generated succesfully")
# # audit_vector_integration(script_file_path,script_id,request)
# update_progress(userId=request.user.id, progress=50)
# except Exception as e:
# update_progress(userId=request.user.id, progress=0)
# time.sleep(20)
# delet_user_progress(userId=request.user.id)
# sys.exit(e)
# print("vector:","outside vector generation")
script_info = db[ScriptDatabase].find_one({"script_id": script_id})
VectorDatabase = "mnfapp_pitchvector"
vector_info = db[VectorDatabase].find_one({"script_id": script_id})
# Blockchain data
# script_info1 = converted_dict["MNFScriptDatabase1"]
# vector_info1 = converted_dict["pitchvector1"]
# try:
print("vector:","outside vector generation")
MNFScriptDatabase1 = eval(request.session["MNFScriptDatabase1"])
pitchvector1 = eval(request.session["pitchvector1"])
if script_info != None:
# Code to convert docx to pdf
"""
str1 = "unoconv -f pdf"
str2 = script_info.get("script_file_path")
str3 = str1 + " " + str2
print("Filpath:", script_info.get("script_file_path"))
os.system(str3)
print("File converted")
temp = script_info.get("script_file_path").split("/")
temp = temp[-1].split(".")
# print(rf"{basePath}/MNF/media/PdfFiles/{temp} + '.pdf'")
"""
document_name = script_info["document_name"][0:-5]
script_info[
"script_file_pdf_path"
] = rf"{basePath}/media/PdfFiles/{document_name}.pdf"
print("Pitch Creation", script_info)
script_info["narration_video_path"] = ""
script_info["line_by_line_narration_video_path"] = ""
script_info["script_genre"] = ""
# MNFScriptDatabase1["script_file_pdf_path"] = rf"{basePath}/media/PdfFiles/{document_name}.pdf"
# Blockchain
# pdf = PdfFileReader(open(script_info.get("script_file_pdf_path"), "rb"))
# number_of_pages = pdf.getNumPages()
# print("No. of pages in PDF:", number_of_pages)
# script_info["number_of_pages"] = int(number_of_pages)
# /////////////
db[ScriptDatabase].save(script_info)
else:
print(" Entry for script id not found")
# restrict = request.GET["restrict_to_five"]
# narration_generation.narration_function(script_id, restrict)
# narration_generation.narration_function(script_id)
# linebyline_narration.line_by_line_narration(script_id) #changed 12th March
print(
"**************************************************************************************************************"
)
print(
"******************************_______*************************************************************************"
)
# screenplay_main.screenplay_function(script_id)
# pitch_function.pitch_function(script_id)
print("________start here______")
script_title = script_info.get("script_title")
print("$$")
# manoj
service_name_list = []
videopath_for_email=[]
if script_info["characterwise_narration"] == "True":
"""
access selected_characters here from database
run characterwise script generation function
"""
try:
print("________characterwise_narration______")
selected_character = vector_info["selected_characters"]
# selected_character = script_info["selected_characters"]
input_dir = request.session.get("script_dir_url")
input_filename = request.session["script_name"]
selected_character = json.loads(
selected_character) # json string to list
#-----------------------------------------------------------modified audit
print("SELECTED CHARACTER",selected_character)
script_id_audit = request.session["script_id_audit"]
print("yameen script_id_audit",script_id_audit)
# script_audit_obj = NeutralAudit(script_id_audit)
# dic_of_chr_path = script_audit_obj.get_character_subset(selected_character)
neutral_aud = NeutralAudit(script_id_audit)
char_sub = neutral_aud.get_character_subset(selected_character)
print("CHARACTER SUBSET",char_sub)
# dic_of_chr_path = mnf_ss.get_subset_character_script(
# input_dir, input_filename, selected_character
# )
with open("/home/user/mnf/project/MNF/Pitchdeck/error_check.txt","a") as file01:
file01.write("8." +str(char_sub) + "\n")
dic_of_chr_path = char_sub
#-------------------------------------------------------------------end
logging.debug(f"slected_charcter {selected_character}")
with open("/home/user/mnf/project/MNF/Pitchdeck/error_check.txt","a") as file01:
file01.write("selected characters list----------" +str(selected_character) + "\n")
print("Out of Mohit Function")
path_list = []
# character_pagecount=[]
for i in selected_character:
print("Entering loop of character ,", i)
c = MNFScriptDatabase()
c.script_id = "scr_" + str(int(time.time()))
print("script neha","scr_" + str(int(time.time())))
# logging.debug(f"slected_charcter {f"script neha scr_{str(int(time.time()))}")
# c.main_script_id = script_info["main"]
print("script_info connecting_id",
script_info["connecting_id"])
# c.connecting_id = script_id
c.connecting_id = script_info
print("Printing Script id of first character", c.script_id)
c.script_title = script_title + \
"_" + str(i) # session variable
url = dic_of_chr_path[i]
pdfname = url.split("/")[-1][0:-5] + ".pdf"
c.script_file_path = url
str1 = "unoconv -f pdf"
# str2 = script_info.get("script_file_path")
# str2 = url.replace(" ","_")
str2 = url
str3 = str1 + " " + '"' + str2 + '"'
print("Filpath:", url)
os.system(str3)
print("File converted")
temp = url.split("/")
# name.docx
temp = temp[-1].split(".")
# c.script_file_pdf_path = rf"{basePath}/media/PdfFiles/{temp[0]}"+ ".pdf"
c.script_file_pdf_path = rf"{url[:-5]}" + ".pdf"
with open("/home/user/mnf/project/MNF/Pitchdeck/error_check.txt","a") as file01:
file01.write("9. script file pdf path"+ str(c.script_file_pdf_path) + "\n")
print("printing script path", c.script_file_pdf_path)
print("printing url", url)
print(
"************************",
rf"{basePath}/media/PdfFiles/{temp[0]}" + ".pdf",
)
# pdf = PdfFileReader(open(rf"{basePath}/media/PdfFiles/{temp[0]}"+ ".pdf", "rb"))
pdf = PdfFileReader(open(rf"{c.script_file_pdf_path}", "rb"))
# number_of_pages = countPages(
# url, pdfname) # get the page count
print("1")
number_of_pages = pdf.getNumPages()
# character_pagecount.append(number_of_pages)
print("1")
c.numPages = number_of_pages
# print("1")
# c.script_file_path = url
print("1")
c.actionline_language = request.session["non_dial_src_lang"]
print("1")
c.actionline_script_language = request.session["non_dial_src_script"]
print("1")
c.dialogues_script_language = request.session["dial_src_script"]
print("1")
c.dialogues_language = request.session["dial_src_lang"]
if "author_name" in request.session:
c.author_name = request.session["author_name"]
print("1")
# c.user_id = script_info["user_id_id"]
# c.user_id = request.user
print("1")
c.save()
print("Vector Creating for Character")
print("script path", c.script_file_path)
print("script id", c.script_id)
with open("/home/user/mnf/project/MNF/Pitchdeck/error_check.txt","a") as file01:
file01.write("9." + str(i) + str(c.script_file_path)+str(c.script_id) + "\n")
with open("/home/user/mnf/project/MNF/Pitchdeck/error_check.txt","a") as file01:
file01.write("10.generated vectors for" + str(i) + "\n")
vector_generation.vector_gen(c.script_file_path, c.script_id)
print(f"Vector Created for {script_title}")
# c.save()
print(i)
path = char_function(script_id,i)
with open("/home/user/mnf/project/MNF/Pitchdeck/error_check.txt","a") as file01:
file01.write("11.path of character " + str(path) + "\n")
print("path neehhhhaa",path)
linebyline_narration.line_by_line_narration(
c.script_id,True, path) # error here
with open("/home/user/mnf/project/MNF/Pitchdeck/error_check.txt","a") as file01:
file01.write("12. line by line complete " + "\n")
print("Characterwise Video Created")
c.line_by_line_narration_video_path = (
rf"{basePath}/media/videos/Narrated_Videos/{c.script_title}.webm"
)
# lst.append()
path_list.append(
rf"{basePath}/media/videos/Narrated_Videos/{c.script_title}.webm"
)
print(path_list,"######################## path list ########################")
data_for_blockchain.append(rf"{basePath}/media/videos/Narrated_Videos/{c.script_title}.webm")
# exit()
script_info["selected_characters"] = json.dumps(selected_character)
script_info["characterwise_video_path"] = json.dumps(path_list)
MNFScriptDatabase1["selected_characters"] = json.dumps(selected_character)
MNFScriptDatabase1["characterwise_video_path"] = json.dumps(path_list)
# data_for_blockchain.append(json.dumps(path_list))
db[ScriptDatabase].save(script_info)
print("Characterwise Narration Video Created")
#----------use for email path
email_path=script_info["characterwise_video_path"]
videopath_for_email.append(email_path)
# manoj
service_name_list.append("Characterwise Narration")
with open("/home/user/mnf/project/MNF/Pitchdeck/error_check.txt","a") as file01:
file01.write("11.END of characterwise Narration" +"\n")
except Exception as e:
update_progress(userId=request.user.id, progress=0)
time.sleep(10)
delet_user_progress(userId=request.user.id)
sys.exit(e)
# print("will this work",dic_of_chr_path)
if script_info["onepager"] == "True":
try:
with open("/home/user/mnf/project/MNF/Pitchdeck/error_check1.txt","a") as file01:
file01.write("one pager started" +"\n")
print("Before pager_function", script_id)
with open("/home/user/mnf/project/MNF/Pitchdeck/error_check.txt1","a") as file01:
file01.write("one pager started" +str(script_id)+"\n")
Pager_function.pager_function(script_id)
script_info[
"onepager_pdf_path"
] = rf"{basePath}/media/Onepager/{script_title}.pdf"
data_for_blockchain.append(
rf"{basePath}/media/Onepager/{script_title}.pdf")
# db[ScriptDatabase].save(script_info)
print("One Pager generated sucessfully")
with open("/home/user/mnf/project/MNF/Pitchdeck/error_check1.txt","a") as file01:
file01.write("One Pager generated sucessfully" + str(script_info["onepager_pdf_path"]) + "\n")
# Blockchain
MNFScriptDatabase1["onepager_pdf_path"] = rf"{basePath}/media/Onepager/{script_title}.pdf"
with open("/home/user/mnf/project/MNF/Pitchdeck/error_check1.txt","a") as file01:
file01.write("After mnfblockchain" + "\n")
temp_dir = tempfile.mkdtemp()
short_path = os.path.join(temp_dir, "file.pdf")
Onepagerfile = rf"{basePath}/media/Onepager/{script_title}.pdf"
with open(Onepagerfile, 'rb') as source_file, open(short_path, 'wb') as target_file:
target_file.write(source_file.read())
hash = uploadDataToIPFSNode(short_path)
os.remove(short_path)
os.rmdir(temp_dir)
MNFScriptDatabase1["Onepager_Script_fileHash"] = hash
with open("/home/user/mnf/project/MNF/Pitchdeck/error_check1.txt","a") as file01:
file01.write("After mnfblockchain" +hash+ "\n")
# hash = response.json()["hash"]
# with open("/home/user/mnf/project/MNF/Pitchdeck/error_check1.txt","a") as file01:
# file01.write("Blockchainfile: " + str(hash) + "\n")
# #use for email path
email_path=script_info["onepager_pdf_path"]
videopath_for_email.append(email_path)
# manoj
service_name_list.append("One Pager")
except Exception as e:
update_progress(userId=request.user.id, progress=0)
time.sleep(10)
delet_user_progress(userId=request.user.id)
sys.exit(e)
if script_info["screenplay_analysis"] == "True":
try:
print("Rohit before")
with open("/home/user/mnf/project/MNF/Pitchdeck/error_check.txt","a") as file01:
file01.write("Screenplay started" + "\n")
screenplay_main.screenplay_function(script_id)
print("Rohit after")
script_info[
"screenplay_analysis_video_path"
] = rf"{basePath}/media/Screenplay/{script_title}_screenplay.webm"
with open("/home/user/mnf/project/MNF/Pitchdeck/error_check.txt","a") as file01:
file01.write('path of screenplay'+str(script_info["screenplay_analysis_video_path"])+"\n")
data_for_blockchain.append(
rf"{basePath}/media/Screenplay/{script_title}_screenplay.webm"
)
with open("/home/user/mnf/project/MNF/Pitchdeck/error_check.txt","a") as file01:
file01.write('blockchain'+"\n")
db[ScriptDatabase].save(script_info)
print("Screenplay generated sucessfully")
with open("/home/user/mnf/project/MNF/Pitchdeck/error_check.txt","a") as file01:
file01.write('screenplay generated'+"\n")
# blockchain
temp_dir = tempfile.mkdtemp()
short_path = os.path.join(temp_dir, "file.pdf")
MNFScriptDatabase1["screenplay_analysis_video_path"] = rf"{basePath}/media/Screenplay/{script_title}_screenplay.webm"
Screenplayfile = rf"{basePath}/media/Screenplay/{script_title}_screenplay.webm"
with open(Screenplayfile, 'rb') as source_file, open(short_path, 'wb') as target_file:
target_file.write(source_file.read())
hash = uploadDataToIPFSNode(short_path)
os.remove(short_path)
os.rmdir(temp_dir)
print("HASH>>>",hash)
MNFScriptDatabase1["Screenplayh_Script_fileHash"] = hash
#use for email path
email_path= script_info["screenplay_analysis_video_path"]
videopath_for_email.append(email_path)
# manoj
service_name_list.append("Screenplay Analysis")
except Exception as e:
update_progress(userId=request.user.id, progress=0)
time.sleep(10)
delet_user_progress(userId=request.user.id)
sys.exit(e)
if script_info["elevator_pitch"] == "True":
try:
print("Entering ElevatorPitch: ")
with open("/home/user/mnf/project/MNF/Pitchdeck/error_check.txt","a") as file01:
file01.write("Elevator started" + "\n")
pitch_function.pitch_function(script_id)
script_info["elevator_pitch_video_path"] = (
rf"{basePath}/media/Pitch/" +
str(script_title) + "_pitchdeck.webm"
)
#Blockchain
temp_dir = tempfile.mkdtemp()
short_path = os.path.join(temp_dir, "file.pdf")
MNFScriptDatabase1["elevator_pitch_video_path"] = rf"{basePath}/media/Pitch/" +str(script_title) + "_pitchdeck.webm"
ElevatorPitchfile = rf"{basePath}/media/Pitch/" +str(script_title) + "_pitchdeck.webm"
with open(ElevatorPitchfile, 'rb') as source_file, open(short_path, 'wb') as target_file:
target_file.write(source_file.read())
hash = uploadDataToIPFSNode(short_path)
os.remove(short_path)
os.rmdir(temp_dir)
MNFScriptDatabase1["ElevatorPitch_Script_fileHash"] = hash
data_for_blockchain.append(
rf"{basePath}/media/Pitch/" +
str(script_title) + "_pitchdeck.webm"
)
print("ElevatorPitch generated sucessfully")
with open("/home/user/mnf/project/MNF/Pitchdeck/error_check.txt","a") as file01:
file01.write("ElevatorPitch generated sucessfully" + str(script_info["elevator_pitch_video_path"]) + "\n")
db[ScriptDatabase].save(script_info)
print("Rohit2")
#use for email path
email_path= script_info["elevator_pitch_video_path"]
videopath_for_email.append(email_path)
# manoj
service_name_list.append("Elevator Pitch")
except Exception as e:
update_progress(userId=request.user.id, progress=0)
time.sleep(10)
delet_user_progress(userId=request.user.id)
sys.exit(e)
if script_info["character_intro"] == "True":
try:
print("----Entering character introduction-----")
with open("/home/user/mnf/project/MNF/Pitchdeck/error_check.txt","a") as file01:
file01.write("character introduction started" + "\n")
# obj = TestingC.Char_video_class(script_id)
# characterdata = obj.char_data_written()
# for i in characterdata:
# obj.first_intro_page(i)
Char_function.char_function(script_id)
script_info["character_intro_video_path"] = rf'{basePath}/media/character_Intro/{str(script_title)}.webm'
# # # data_for_blockchain.append(rf"{basePath}/media/Pitch/" + str(script_title) + "_pitchdeck.webm")
print("character introduction generated sucessfully")
with open("/home/user/mnf/project/MNF/Pitchdeck/error_check.txt","a") as file01:
file01.write("Character introduction generated sucessfully" + str(script_info["character_intro_video_path"]) + "\n")
db[ScriptDatabase].save(script_info)
print("Rohit2")
#Blockchain
temp_dir = tempfile.mkdtemp()
short_path = os.path.join(temp_dir, "file.pdf")
MNFScriptDatabase1["character_intro_video_path"] = rf"{basePath}/media/Screenplay/{script_title}_screenplay.webm"
Characterfile = rf'{basePath}/media/character_Intro/{str(script_title)}.webm'
with open(Characterfile, 'rb') as source_file, open(short_path, 'wb') as target_file:
target_file.write(source_file.read())
hash = uploadDataToIPFSNode(short_path)
os.remove(short_path)
os.rmdir(temp_dir)
MNFScriptDatabase1["Characterfile_Script_fileHash"] = hash
#use for email path
email_path= script_info["character_intro_video_path"]
videopath_for_email.append(email_path)
# manoj
service_name_list.append("Character Introduction")
except Exception as e:
update_progress(userId=request.user.id, progress=0)
time.sleep(10)
delet_user_progress(userId=request.user.id)
sys.exit(e)
if script_info["linebyline"] == "True":
try:
print("Rohit3")
with open("/home/user/mnf/project/MNF/Pitchdeck/error_check1.txt","a") as file01:
file01.write("Line by line started" + "\n")
linebyline_narration.line_by_line_narration(script_id)
with open("/home/user/mnf/project/MNF/Pitchdeck/error_check1.txt","a") as file01:
file01.write("line by line complete" +"\n")
print("Narration generated sucessfully")
script_title = script_info.get("script_title")
# script_info[
# 'narration_video_path'] = rf"{basePath}/media/videos/Narrated_Videos/{script_title}.webm"
script_info[
"line_by_line_narration_video_path"
] = rf"{basePath}/media/videos/Narrated_Videos/{script_title}.webm"
with open("/home/user/mnf/project/MNF/Pitchdeck/error_check1.txt","a") as file01:
file01.write("Line by line path" + str(script_info["line_by_line_narration_video_path"])+ "\n")
script_info["narration_video_path"] = script_info[
"line_by_line_narration_video_path"
]
with open("/home/user/mnf/project/MNF/Pitchdeck/error_check.txt","a") as file01:
file01.write("Line by line generated sucessfully-----------------" + str(script_info["narration_video_path"]) + "\n")
#Blockchain
temp_dir = tempfile.mkdtemp()
short_path = os.path.join(temp_dir, "file.pdf")
MNFScriptDatabase1["line_by_line_narration_video_path"] = rf"{basePath}/media/Screenplay/{script_title}_screenplay.webm"
narrationfile = rf"{basePath}/media/videos/Narrated_Videos/{script_title}.webm"
with open(narrationfile, 'rb') as source_file, open(short_path, 'wb') as target_file:
target_file.write(source_file.read())
hash = uploadDataToIPFSNode(short_path)
os.remove(short_path)
os.rmdir(temp_dir)
MNFScriptDatabase1["narration_Script_fileHash"] = hash
with open("/home/user/mnf/project/MNF/Pitchdeck/error_check.txt","a") as file01:
file01.write("Line by line generated sucessfully" + str(script_info["narration_video_path"]) + "\n")
#use for email path
email_path= script_info["line_by_line_narration_video_path"]
videopath_for_email.append(email_path)
# manoj
service_name_list.append("Line by line")
except Exception as e:
update_progress(userId=request.user.id, progress=0)
time.sleep(10)
delet_user_progress(userId=request.user.id)
sys.exit(e)
# data_for_blockchain.append(script_info["narration_video_path"])
# Blockchain
print("/n/n/n/n/nn/n/ngenarate all servies/n/n/n/n")
if UserCredentialsForBlockchain.objects.filter(user=request.user).exists():
blockchain_obj = UserCredentialsForBlockchain.objects.get(user=request.user)
MNFDatabase = {}
MNFDatabase["MNFScriptDatabase1"] = MNFScriptDatabase1
MNFDatabase["pitchvector1"] = pitchvector1
key1= "MyNextFilm"
UserId = blockchain_obj.user_id
project = request.session["blockchainscript_id"]
Data = str(MNFDatabase)
userPrivateKey = blockchain_obj.privateKey
userkey =decryptionOfPrivate(userPrivateKey)
hash = NarrationData(userkey.decode('utf-8'),UserId, project,Data)
print("my_tx_hash",hash)
context = {
"status": "Success",
}
user = request.user
email = user.email
# ------------------------------------------------------blockchain
# script_path = str(rf"{basePath}/media/scripts/{script_title}")
print("list ", data_for_blockchain)
# data = [script_path, data_for_blockchain ]
# print("All Files ",data)
print("Function 11")
update_progress(userId=request.user.id, progress=85)
try:
files, timestamp = upload_zipfile_to_ipfs(
data_for_blockchain, str(script_title), "pitchdeck", email
)
script_info["timestamp"] = timestamp
print("timestamp of blockchain", files, timestamp)
script_info["uploaded_script_encoded"] = files
# script_info["translated_script_encoded"] = files[1]
db[ScriptDatabase].save(script_info)
except Exception as e:
update_progress(userId=request.user.id, progress=0)
time.sleep(10)
delet_user_progress(userId=request.user.id)
sys.exit(e)
# ---------------------------------------------------------------------------
#use for email click here path
with open("/home/user/mnf/project/MNF/Pitchdeck/error_check.txt","a") as file01:
file01.write("videopath_for_email." +str(videopath_for_email) + "\n")
click_for_email= ""
if len(videopath_for_email) == 1:
click_for_email = str(videopath_for_email[0])
print(click_for_email)
else:
click_for_email= ", ".join(videopath_for_email[:-1]) + " and " + videopath_for_email[-1]
print(click_for_email)
current_site = get_current_site(request)
context = {
"domain": current_site.domain,
"serviceName": "Pitch Creation",
"name": email,
"amount": request.POST.get("total_amount"),
# "click_email":click_for_email,
# "timestamp":timestamp,
# "key":script_title
}
# manoj for creating new subject according to services they used
subject_accordingto_service_list = ""
if len(service_name_list) == 1:
subject_accordingto_service_list = str(service_name_list[0])
else:
subject_accordingto_service_list = ", ".join(service_name_list[:-1]) + " and " + service_name_list[-1]
# manoj new subject line
# subject_accordingto_service_list += " narrated successfully"
num_pages = request.session["numPages"]
if num_pages > 5: # ----------------neha
request.session["pages_greater_than_five"] == "true"
to_email = [request.user.email]
email_code = 'TN1'
sendmail(to_email=to_email , email_code=email_code ,key_value={'service_name':subject_accordingto_service_list})
# message = render_to_string("narration/MR31.html", context)
# text_content = strip_tags(message)
# msg = EmailMultiAlternatives(
# subject_accordingto_service_list,
# text_content,
# settings.EMAIL_HOST_USER,
# [email],
# )
# msg.attach_alternative(message, "text/html")
# msg.send()
else:
# send mail only for confirmation hjgjh
request.session["pages_greater_than_five"] = "false" # --------neha
to_email = [request.user.email]
email_code = 'TN1'
sendmail(to_email=to_email , email_code=email_code )
# message = render_to_string("narration/MR31.html", context)
# text_content = strip_tags(message)
# msg = EmailMultiAlternatives(
# subject_accordingto_service_list,
# text_content,
# settings.EMAIL_HOST_USER,
# [email],
# )
# msg.attach_alternative(message, "text/html")
# msg.send()
del request.session["pages_greater_than_five"]
var = Notifications(
user_id=request.user,
notification=str(
"Narration generated successfully for " + script_title),
)
var.save()
update_progress(userId=request.user.id, progress=100)
time.sleep(10)
delet_user_progress(userId=request.user.id)
return JsonResponse(context)
# except Exception as e:
print("error is ", e)
payment_intent_id = script_info.get("payment_intent_id")
print("thisisgonnabeaRefund")
if payment_intent_id:
if payment_intent_id[0:4] == "pay":
client = razorpay.Client(auth=(keyID, keySecret))
payment_id = payment_intent_id
paydetail = client.payment.fetch(payment_id)
total_amount = request.POST.get("total_amount") - (paydetail["fee"] / 100)
try:
c = CurrencyRates()
rate = c.get_rate("USD", "INR")
except Exception as e:
print("pich creation", e)
rate = 80
payment_amount = int(float(total_amount) * 100 * rate)
client.payment.refund(
payment_id,
{
"amount": payment_amount,
"speed": "normal",
},
)
else:
stripe.Refund.create(payment_intent_id)
user = request.user
email = user.email
context = {
"serviceName": "Pitch Creation",
"name": email,
}
message = render_to_string("narration/MR28.html", context)
text_content = strip_tags(message)
msg = EmailMultiAlternatives(
"Incovenience is regretted",
text_content,
settings.EMAIL_HOST_USER,
[email],
)
msg.attach_alternative(message, "text/html")
msg.send()
user = request.user
email = user.email
context = {
"serviceName": "Pitch Creation",
"name": email,
}
message = render_to_string("narration/MR23.html", context)
text_content = strip_tags(message)
# create the email, and attach the HTML version as well.
msg = EmailMultiAlternatives(
"We are investigating the reason",
text_content,
settings.EMAIL_HOST_USER,
[email],
)
msg.attach_alternative(message, "text/html")
msg.send()
return JsonResponse({}, status=500)
def progress_sender(request):
# Simulating a long-running task
print("Reached Progress_sender")
userId = request.user.id
progress = progress_dict.get(userId)
if userId in progress_dict:
if progress is not None:
old_progress = old_progress_dict.get(userId)
while old_progress == progress:
# Add a small delay to reduce CPU usage
time.sleep(1)
progress = progress_dict.get(userId)
print("New Value send --->>", progress)
if progress == 0:
old_progress_dict[userId] = progress
data = {'status': 'error', 'progress': progress}
return JsonResponse(data)
if progress == 100:
old_progress_dict[userId] = progress
data = {'status': 'completed', 'progress': progress}
return JsonResponse(data)
old_progress_dict[userId] = progress
data = {'status': 'in_progress', 'progress': progress}
return JsonResponse(data)
data = {'status': 'no_update'}
return JsonResponse(data)
# # Get the progress value from the task (replace with your logic)
# progress = get_progress()
# # Check if the progress has reached 100% or not
# if progress >= 100:
# # If the progress is complete, return the final result
# data = {'status': 'completed', 'progress': 100, 'result': 'Task completed successfully'}
# else:
# # If the progress is not complete, return the progress value
# data = {'status': 'in_progress', 'progress': progress}
# return JsonResponse(data)
# progress_dict = {}
# old_progress_dict = {}
# except Exception as e:
# print("error is ", e)
# payment_intent_id = script_info.get("payment_intent_id")
# print("thisisgonnabeaRefund")
# if payment_intent_id:
# if payment_intent_id[0:4] == "pay":
# client = razorpay.Client(auth=(keyID, keySecret))
# payment_id = payment_intent_id
# paydetail = client.payment.fetch(payment_id)
# total_amount = request.POST.get("total_amount") - (paydetail["fee"] / 100)
# try:
# c = CurrencyRates()
# rate = c.get_rate("USD", "INR")
# except Exception as e:
# print("pich creation", e)
# rate = 80
# payment_amount = int(float(total_amount) * 100 * rate)
# client.payment.refund(
# payment_id,
# {
# "amount": payment_amount,
# "speed": "normal",
# },
# )
# else:
# stripe.Refund.create(payment_intent_id)
# user = request.user
# email = user.email
# context = {
# "serviceName": "Pitch Creation",
# "name": email,
# }
# message = render_to_string("narration/MR28.html", context)
# text_content = strip_tags(message)
# msg = EmailMultiAlternatives(
# "Incovenience is regretted",
# text_content,
# settings.EMAIL_HOST_USER,
# [email],
# )
# msg.attach_alternative(message, "text/html")
# msg.send()
# user = request.user
# email = user.email
# context = {
# "serviceName": "Pitch Creation",
# "name": email,
# }
# message = render_to_string("narration/MR23.html", context)
# text_content = strip_tags(message)
# # create the email, and attach the HTML version as well.
# msg = EmailMultiAlternatives(
# "We are investigating the reason",
# text_content,
# settings.EMAIL_HOST_USER,
# [email],
# )
# msg.attach_alternative(message, "text/html")
# msg.send()
# return JsonResponse({}, status=500)
# class PostStreamView(View):
# def get(self, request):
# obj = ProgressNarration.objects.filter(user_id=request.user.id).last()
# if obj:
# print("Processing Chal Rahi hai", obj.progress)
# if obj.progress == 100:
# return JsonResponse({"status": "success", "progress": obj.progress}, status=200)
# if obj.progress == 0:
# return JsonResponse({"status": "Failed"}, status=500)
# else:
# return JsonResponse({"status": "pending", "progress": obj.progress}, status=202)
# else:
# return JsonResponse({"status": "Do nothing"}, status=203)
# def my_process(progress):
# progress_updated.send(sender=None, progress=progress)
# class ProgressConsumer(AsyncWebsocketConsumer):
# async def connect(self):
# await self.accept()
# await self.send(json.dumps({'progress': 0}))
# progress_updated.connect(self.progress_updated_handler)
# async def disconnect(self, close_code):
# progress_updated.disconnect(self.progress_updated_handler)
# async def progress_updated_handler(self, event):
# progress = event['progress']
# await self.send(json.dumps({'progress': progress}))
# class ProgressConsumer(WebsocketConsumer):
# def connect(self):
# self.room_name = "test"
# self.room_group_name = "test group"
# async_to_sync(self.channel_layers.group_send)(
# self.room_name, self.room_group_name
# )
# self.accept()
# self.send(text_data = json.dumps({"status":"finally Ran"}))
# def disconnect(self, close_code):
# pass
# def receive(self, text_data):
# pass
# def update_progress(self, event):
# progress = event['progress']
# await self.send(text_data=progress)
# def send_progress_to_client(sender, instance, **kwargs):
# if instance.user_id.id == kwargs['user_id']:
# print("######## Instance Found ###########")
# return instance.progress, instance.user_id.id
# else:
# return None
# SSE Yameen Progress Bar
# def event_stream(userId=None):
# while True:
# progress = progress_dict.get(userId)
# print("In stream, progress", progress)
# if progress is not None:
# print("In stream", old_progress_dict.get(userId), progress)
# if old_progress_dict.get(userId) != progress:
# if progress == 0:
# data = {'progress': progress}
# yield f"data: {json.dumps(data)}\n\n"
# time.sleep(2)
# print("data send ->>>>>", data)
# delet_user_progress(userId=userId)
# break
# elif progress == 100:
# data = {'progress': progress}
# yield f"data: {json.dumps(data)}\n\n"
# time.sleep(2)
# print("data send ->>>>>", data)
# break
# else:
# data = {'progress': progress}
# yield f"data: {json.dumps(data)}\n\n"
# time.sleep(2)
# print("data send ->>>>>", data)
# old_progress_dict[userId] = progress
# else:
# yield 'event: ping\ndata: {}\n\n'
# time.sleep(2)
def update_progress(userId, progress):
if userId in progress_dict:
progress_dict[userId] = progress
print(f"############# Progress Updated {progress} ###########")
time.sleep(3)
def update_old_progress(userId, progress):
if userId in old_progress_dict:
old_progress_dict[userId] = progress
print(f"############# OLD Progress Updated {progress} ###########")
time.sleep(3)
def reset_progress_dict(userId):
if userId in progress_dict and userId in old_progress_dict:
del progress_dict[userId]
del old_progress_dict[userId]
progress_dict[userId] = 20
old_progress_dict[userId] = 0
print("new value intialized",
progress_dict[userId], old_progress_dict[userId])
time.sleep(3)
else:
progress_dict[userId] = 20
old_progress_dict[userId] = 0
print("new value intialized",
progress_dict[userId], old_progress_dict[userId])
time.sleep(3)
def delet_user_progress(userId):
if userId in progress_dict and userId in old_progress_dict:
del progress_dict[userId]
del old_progress_dict[userId]
time.sleep(3)
# @csrf_exempt
# def progress_sender(request):
# user_id = request.user.id
# response = StreamingHttpResponse(event_stream(
# userId=user_id), content_type='text/event-stream')
# response['Cache-Control'] = 'no-cache'
# response['Connection'] = 'keep-alive'
# return response
# @receiver(post_save, sender=ProgressNarration)
# def progress_narration_post_save(sender, instance, **kwargs):
# print("######################### update ##################################")
# print(sender,instance)
# print(instance.progress)
# print(instance.user_id.id)
# progress, userId = send_progress_to_client(sender, instance, user_id=instance.user_id.id)
# if progress:
# print("@@@@@@@@@@@@@@@@@@@@@@@@ New Progress Updated dict #############################")
# print("progress", progress)
# progress_dict[userId] = progress
# update_model(request=None, progress = progress)
# channel_layer = get_channel_layer()
# async_to_sync(channel_layer.group_send)(
# 'progress_group', {'type': 'update_progress', 'progress': progress})
# def stream(request):
# oldProgress = 10
# while True:
# obj = ProgressNarration.objects.filter(user_id=request.user.id).last()
# if obj:
# print("::::::::OBJ:::::::::::")
# print(obj.progress)
# if oldProgress != obj.progress:
# message = {"progress": obj.progress}
# yield f"data: {json.dumps(message)}\n\n"
# print("@@@@@ Data Send @@@@@", obj.progress)
# time.sleep(2)
# oldProgress = obj.progress
# print("oldProgress",oldProgress)
# else:
# yield " " * 1024
# time.sleep(1)
# del oldProgress
# # # @csrf_exempt
# # # @require_GET
# class PostStreamView(View):
# def get(self, request):
# response = StreamingHttpResponse(stream(request))
# response['Content-Type'] = 'text/event-stream'
# response["Cache-Control"] = "no-cache"
# response["Connection"] = "keep-alive"
# response['X-Accel-Buffering'] = 'no'
# response['Timeout'] = '86400'
# return response
# global PROGRESS
# old_counter = PROGRESS
# PROGRESS += 1
# new_counter = PROGRESS
# if old_counter != new_counter:
# # print("progress", new_counter)
# # else:
# # # counter has not been updated
# # pass
# obj = MNFScriptDatabase.objects.filter(user_id=request.user.id, progress__gt=0)
# print("::::::::::::Processing Chal Rahi hai########################################################", obj)
# # if old_counter != new_counter:
# # print("progress", new_counter)
# # if obj.progress == 100:
# # return JsonResponse({"status": "success"}, status=200)
# # elif obj.progress == 0:
# # return JsonResponse({"status": "failed"}, status=500)
# # else:
# # return JsonResponse({"status": "pending", "progress": new_counter}, status=202)
# message = {"progress": new_counter}
# response.write(f"data: {json.dumps(message)}\n\n")
# return JsonResponse({"status": "pending", "progress": new_counter}, status=202)
# else:
# obj = MNFScriptDatabase.objects.filter(user_id=request.user.id, progress__gt=0).first()
# print("::::::::::::Processing Chal Rahi hai########################################################", obj.progress)
# return JsonResponse({"status": "pending", "progress": 20}, status=202)
# yameen on update progress:
# def send_progress_to_client(sender, instance, **kwargs):
# print("######## send_progress_to_client ###########")
# print(instance.user_id, kwargs['user_id'])
# if instance.user_id.id == kwargs['user_id']:
# print("######## Instance Found ###########")
# message = {"progress": instance.progress}
# print("PostStreamView.responses", PostStreamView.responses)
# for response in PostStreamView.responses:
# print("######## Message send ###########")
# print("response", response)
# response.queue.put(f"data: {json.dumps(message)}\n\n")
# class PostStreamView(View):
# responses = []
# def get(self, request):
# print("######## Responce Send ###########")
# response = StreamingHttpResponse(self.stream(request))
# response['Content-Type'] = 'text/event-stream'
# response['Cache-Control'] = 'no-cache'
# response['Connection'] = 'keep-alive'
# response.queue = Queue()
# self.responses.append(response)
# print("response", response)
# return response
# def stream(self, request):
# print("######## In Stream ###########")
# message = {"progress": 0}
# old_data = f"data: {json.dumps(message)}\n\n"
# while True:
# rlist, _, _ = select.select([self.responses[-1].queue.reader], [], [], 1)
# if rlist:
# data = self.responses[-1].queue.get()
# if data:
# old_data = data.encode()
# yield data.encode()
# else:
# pass
# @receiver(post_save, sender=ProgressNarration)
# def progress_narration_post_save(sender, instance, **kwargs):
# print("######################### update ##################################")
# print(sender,instance)
# print(instance.progress)
# print(instance.user_id.id)
# send_progress_to_client(sender, instance, user_id=instance.user_id.id)
from centralizePayment.views import callback, create_indent
def narrationCheckout1(request,script_id):
amount_charged = request.session["amount_charged"]
total_amount = request.session["total_amount"]
discount = request.session["discount"]
service_count=request.session["service_use"]
context = create_indent(request,"pitchdeck",script_id,service_count,"",total_amount,amount_charged,discount)
with open("/home/user/mnf/project/MNF/Pitchdeck/error_check1.txt","a") as file01:
file01.write("narration checkout--------- -->" + str(context)+ "\n")
narration_instance = PitchVector.objects.get(id=script_id) # get object from your service database
with open("/home/user/mnf/project/MNF/Pitchdeck/error_check1.txt","a") as file01:
file01.write("narration checkout--------- -->" + str(narration_instance)+ "\n")
# handle razor pay gateway →
if "orderId" in context:
narration_instance.order_id = context["orderId"]
narration_instance.cp_id = context["central_pay_id"]
narration_instance.save() # save central payment details in your database
# handle stripe gateway →
elif "client_secret" in context:
narration_instance.order_id = context["client_secret"]
narration_instance.cp_id = context["central_pay_id"]
narration_instance.save() # save central payment details in your database
# handle corporate profile →
elif "corporate" in context:
narration_instance.order_id = "corporate profile"
narration_instance.cp_id = "corporate profile"
narration_instance.save() # save central payment details in your database
# # run service in thread →
# # thread = Thread(target=run_subtitle, args=(payment_object,))
# # thread.start()
return render(request, "template.html", {"message":"bill added to the corporate profile"})
else:
# # handle errors →
return render(request, "template.html", {"message":"invalid request!"})
# handle success →
return render(request, "template.html", context)
def post(request):
response = request.POST.data # Get payment response
# call central payment callback function →
data = callback(response, request)
# handle success status →
if data["payment_status"] == "success":
# get object
payment_object =PitchVector.objects.get(cp_id=data["central_pay_id"])
payment_object.transaction_id = data["payment_id"]
payment_object.isPaid = True
payment_object.save() # save payment information
# run service in thread → demo
# thread = Thread(target=run_subtitle, args=(payment_object,))
# thread.start()
return render(request,"template.html",{"status": "Payment Done"})
# handle errors →
else:
render(request,"template.html",{"error_data": "Payment Failed"})
def narrationCheckout(request):
set_payment_token(request)
keyID = request.session["keyID"]
keySecret = request.session["keySecret"]
# num_pages = request.session["numPages"]
# print(funcname)
narration_instance = PitchVector.objects.get(script_id=request.session["script_id"])
if request.method == "POST":
# if num_pages > 5 :
total_amount = request.session["amount_charged"]
# script_id=request.session["script_id"]
# narrationCheckout1(request,script_id)
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
request.session["pay_with_wallet"] = "no"
if request.POST["pay_with_wallet"] == "yes":
request.session["pay_with_wallet"] = "yes"
balance = float(request.POST["balance"])
payable = float(request.POST["payable"])
wall = Wallet.objects.get(user=request.user)
request.session["fbalance"] = wall.balance - (balance * rate)
wall.save()
request.session["amount_charged"] = payable
total_amount = request.session["amount_charged"]
amtINR = round((float(total_amount) * rate), 2)
print("pitamtch:", total_amount, type(total_amount))
if request.session["indent_context"]:
client = razorpay.Client(auth=(keyID, keySecret))
if "orderId" in request.session["indent_context"]:
# client = razorpay.Client(auth=(keyID, keySecret))
request.session["payment_order_id"] = request.session["indent_context"]["orderId"]
request.session["central_payment_id"] = request.session["indent_context"]["central_pay_id"]
centralPayment_instance = CentralPayment.objects.get(id=request.session["indent_context"]["central_pay_id"])
pid = centralPayment_instance.order_id
amtINR = centralPayment_instance.amount_charged * rate
context = {
"pk": keyID,
"amtINR": amtINR,
"pid": pid,
"amount": centralPayment_instance.amount_charged,
}
return render(
request,
"Pitchdeck/checkoutN_RazorPay.html",
context
)
elif "client_secret" in request.session["indent_context"]:
request.session["payment_order_id"] = request.session["indent_context"]["client_secret"] # save central payment details in your database
request.session["central_payment_id"] = request.session["indent_context"]["central_pay_id"]
amtINR = centralPayment_instance.amount_charged * rate
context = {
"pk": STRIPE_PUB_KEY,
"total_amount": centralPayment_instance.amount_charged,
"secret_key":request.session["indent_context"]["client_secret"],
"amtINR": amtINR,
"STRIPE_PUBLISHABLE_KEY": STRIPE_PUB_KEY,
}
return render(request, "Pitchdeck/checkoutNnew.html", context)
elif "corporate" in request.session["indent_context"]:
script_id=request.session["script_id"]
numPages = request.session["numPages"]
actionline_language = request.session["actionline_language"]
actionline_script_language = request.session["actionline_script_language"]
dialogues_language = request.session["dialogues_language"]
dialogues_script_language = request.session["dialogues_script_language"]
script_title = request.session["script_title"]
script_file_path = request.session["script_file_path"]
request.session["payment_order_id"] = "corporate profile"
request.session["central_payment_id"] = "corporate profile"
return render(request, "Pitchdeck/PitchnarratedVideos.html", context)
else:
# return render(request, "payments/failed.html")
to_email = [request.user.email]
email_code = 'TN4'
sendmail(to_email=to_email , email_code=email_code )
return render(request, "payments/failed.html")
return render(request, "Pitchdeck/Pitchnarrate1.html")
@login_required(login_url="/")
def narrationcard(request):
if request.method == "POST":
# print("thisispayment_intent_id::", request.POST["payment_intent_id"])
# payment_intent_id = request.POST["payment_intent_id"]
# payment_method_id = request.POST["payment_method_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={}
# context = {
# "payment_intent_secret": pi.client_secret,
# "id": pi.id,
# "pk": STRIPE_PUB_KEY,
# }
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,
}
return render(request, "Pitchdeck/3dsecuredNarration.html", context)
# return render(request, "payments/paymentdone.html")
else:
return render(request, "Pitchdeck/Pitchnarrate1.html")
@login_required(login_url="/")
def paymentDoneN_RazorPay(request):
# keyID = request.session["keyID"]
# keySecret = request.session["keySecret"]
# razorpay_order_id = request.POST["razorpay_order_id"]
# print(razorpay_order_id)
if request.method == 'POST':
callback_payment = callback(request.POST, request)
if callback_payment['payment_status'] == 'success':
# print("manoj#45454")
# print(request.POST["razorpay_order_id"])
# 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:
# user = request.user
# email = user.email
# context = {
# "serviceName": "Pitch Creation",
# "name": email,
# }
# message = render_to_string("narration/MR24.html", context)
# text_content = strip_tags(message)
# # create the email, and attach the HTML version as well.
# msg = EmailMultiAlternatives(
# "Something really went wrong",
# text_content,
# settings.EMAIL_HOST_USER,
# [email],
# )
# msg.attach_alternative(message, "text/html")
# msg.send()
# to_email = [request.user.email]
# email_code = 'TN4'
# sendmail(to_email=to_email , email_code=email_code )
# return render(request, "payments/failed.html")
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
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()
else:
pass
total_amount = round(float((request.session["total_amount"]) * rate), 2)
# paydetail = client.payment.fetch(razorpay_payment_id)
# user_id = request.user
# payment_id = razorpay_payment_id
amount_charged = round(float((request.session["amount_charged"]) * rate), 2)
discount = round((total_amount - amount_charged), 2)
# gateway_fee = paydetail["fee"] / 100 # to convert from paise to rupees
# currency = paydetail["currency"]
# pay_method = paydetail["method"]
# services_used = "Pitchdeck"
# payment_status = "Success"
# payment_gateway = "RazorPay"
# number_of_pages = request.session["numPages"]
# script_in = MNFScriptDatabase.objects.get(
# script_id=request.session["script_id"]
# )
# with open("/home/user/mnf/project/MNF/Pitchdeck/error_check.txt","a") as file01:
# file01.write('Detailed complete'+"\n")
# PaymentData.objects.create(
# user_id=user_id,
# payment_id=payment_id,
# services_used=services_used,
# discount=discount,
# number_of_pages=number_of_pages,
# total_amount=total_amount,
# amount_charged=amount_charged,
# gateway_fee=gateway_fee,
# script_info=script_in,
# currency=currency,
# pay_method=pay_method,
# payment_status=payment_status,
# payment_gateway=payment_gateway,
# )
# with open("/home/user/mnf/project/MNF/Pitchdeck/error_check.txt","a") as file01:
# file01.write('PaymentData created'+"\n")
# #------------------------------------neha
# # update priviledged user razorpay
# if request.session["UpdatePriviledgedUser"]:
# with open("/home/user/mnf/project/MNF/Pitchdeck/error_check.txt","a") as file01:
# file01.write('Reached Condition request.session["UpdatePriviledgedUser"]'+"\n")
# print("manoj#re343")
# if privilegedUser1.objects.filter(user=request.user).exists():
# with open("/home/user/mnf/project/MNF/Pitchdeck/error_check.txt","a") as file01:
# file01.write('Privilegeduser hai'+"\n")
# obj = privilegedUser1.objects.get(user=request.user)
# else:
# with open("/home/user/mnf/project/MNF/Pitchdeck/error_check.txt","a") as file01:
# file01.write('Privilegeduser Nahi hai'+"\n")
# obj = privilegedUser1()
# obj.user = request.user
# lasto = privilegedUser1.objects.last()
# obj.id = int(lasto.id) + 1
# obj.memberType = "normal"
# obj.is_active = "yes"
# obj.months = 1
# obj.chargeId = razorpay_order_id
# obj.transactionId = razorpay_payment_id
# obj.razorpaySign = razorpay_signature
# obj.status = payment_status
# obj.amount_captured = total_amount
# with open("/home/user/mnf/project/MNF/Pitchdeck/error_check.txt","a") as file01:
# file01.write('Privilegeduser object '+str(obj)+"\n")
# obj.save()
# with open("/home/user/mnf/project/MNF/Pitchdeck/error_check.txt","a") as file01:
# file01.write('Privilegeduser save hoa'+"\n")
# print("manoj*9998ha")
# del request.session["UpdatePriviledgedUser"]
# manoj
s=PitchVector()
# s.transaction_id = callback_payment["payment_id"] # save central payment details in your database
# s.isPaid = True # save central payment details in your database
# s.save()
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"]
s.save()
print("manoj454545454545")
print(amount_charged)
print(request.user.email)
current_site = get_current_site(request)
context2 = {
"domain": current_site.domain,
"serviceName": "Pitch Creation",
"name": request.user.email,
"amount": amount_charged,
"razorpay": True
}
# message = render_to_string("narration/MR25.html", context2)
# text_content = strip_tags(message)
# msg = EmailMultiAlternatives(
# "Every penny of yours is valuable",
# text_content,
# settings.EMAIL_HOST_USER,
# [request.user.email],
# )
# msg.attach_alternative(message, "text/html")
# msg.send()
to_email = [request.user.email]
email_code = 'TN3'
sendmail(to_email=to_email , email_code=email_code )
# manoj end
context = {
"script_id": request.session["script_id"],
"script_file_path": request.session["script_file_path"],
"restrict_to_five": "no",
}
return render(request, "Pitchdeck/PitchnarratedVideos.html", context)
# except:
else:
print("manoj1450")
print(traceback.format_exc())
with open("/home/user/mnf/project/MNF/Pitchdeck/error_check.txt","a") as file01:
file01.write('Privilegeduser in exeception aya hai'+str(ex)+"\n")
# subject = "Something really went wrong"
# from_email = settings.EMAIL_HOST_USER
# to = request.user.email
# context_2 = {
# "Name": request.user.email,
# "service_name": "Pitch Creation",
# }
# mnfnsendemail(
# to, subject, "payment/templates/payments/MR24.html", context_2, from_email
# )
to_email = [request.user.email]
email_code = 'TN4'
sendmail(to_email=to_email , email_code=email_code )
return render(request, "payments/failed.html")
else:
return HttpResponse("You don't have an access to use this.")
@login_required(login_url="/")
def paymentDoneN(request):
if request.method == "GET":
script_id = request.session["script_id"]
num_pages = request.session["numPages"]
actionline_language = request.session["actionline_language"]
actionline_script_language = request.session["actionline_script_language"]
dialogues_language = request.session["dialogues_language"]
dialogues_script_language = request.session["dialogues_script_language"]
document_name = request.session["document_name"]
script_title = request.session["script_title"]
total_amount= request.session["total_amount"]
amount_charged = request.session["amount_charged"]
discount = request.session["discount"]
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)
walls = Wallet.objects.get(user=request.user)
walls.balance = request.session["fbalance"]
walls.save()
else:
pass
s = MNFScriptDatabase()
p=PitchVector()
s.user_id = request.user
s.script_id = script_id
s.script_title = script_title
# s.script_file_path = script_file_path
p.payment_order_id = request.session["payment_order_id"] # save central payment details in your database
p.central_payment_id = request.session["central_payment_id"]
# s.payment_intent_id = payment_intent_id
s.save()
context = {
"script_id": script_id,
"script_title": script_title,
"num_pages":num_pages,
"actionline_language":actionline_language,
"actionline_script_language":actionline_script_language,
"dialogues_language":dialogues_language,
"dialogues_script_language":dialogues_script_language,
"total_amount": total_amount,
"amount_charged":amount_charged,
"discount":discount,
}
to_email = [request.user.email]
email_code = 'TN3'
sendmail(to_email=to_email , email_code=email_code )
# message = render_to_string("narration/MR25.html", context2)
# text_content = strip_tags(message)
# msg = EmailMultiAlternatives(
# "Every penny of yours is valuable",
# text_content,
# settings.EMAIL_HOST_USER,
# [request.user.email],
# )
# msg.attach_alternative(message, "text/html")
# msg.send()
# manoj end
return render(request, "Pitchdeck/PitchnarratedVideos.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": "Pitch Creation",
# }
# mnfnsendemail(
# to,
# subject,
# "payment/templates/payments/MR24.html",
# context_2,
# from_email,
# )
to_email = [request.user.email]
email_code = 'TN4'
context_2 = {
"Name": to_email,
"service_name": "Pitch Creation",
}
sendmail(to_email=to_email , email_code=email_code )
return render(request, "payments/failed.html")
@login_required(login_url="/")
def my_narrations(request):
# obj = MNFScriptDatabase.objects.filter(user_id=request.user).order_by("-date_at").exclude(connecting_id="")
if UserCredentialsForBlockchain.objects.filter(user=request.user).exists():
blockchain_obj = UserCredentialsForBlockchain.objects.get(user=request.user)
videos_path = []
pq= 0
projectIds = getUserprojectIds(blockchain_obj.user_id)
for i in range(len(projectIds) - 1, -1, -1):
print(projectIds[i])
key1= "MyNextFilm"
privatekey = blockchain_obj.privateKey
user_id =blockchain_obj.user_id
Project= projectIds[i]
private_Key = decryptionOfPrivate(privatekey)
status,getData = getNarrationData(private_Key.decode('utf-8'),user_id,Project)
if status == True:
data1 = getData[1]
converted_dict = eval(data1)
if converted_dict.get('MNFScriptDatabase1', {}).get('one_pager') == "True":
hash = converted_dict["MNFScriptDatabase1"]["Onepager_Script_fileHash"]
output_file_path = converted_dict["MNFScriptDatabase1"]["onepager_pdf_path"]
# Save the video to a local file with a progress bar
download_file_System(hash,output_file_path)
if converted_dict.get('MNFScriptDatabase1', {}).get('elevator_pitch') == "True":
hash = converted_dict["MNFScriptDatabase1"]["ElevatorPitch_Script_fileHash"]
output_file_path = converted_dict["MNFScriptDatabase1"]["elevator_pitch_video_path"]
download_file_System(hash,output_file_path)
if converted_dict.get('MNFScriptDatabase1', {}).get('linebyline') == "True":
hash = converted_dict["MNFScriptDatabase1"]["narration_Script_fileHash"]
output_file_path = converted_dict["MNFScriptDatabase1"]["line_by_line_narration_video_path"]
download_file_System(hash,output_file_path)
if converted_dict.get('MNFScriptDatabase1', {}).get('character_intro') == "True":
hash = converted_dict["MNFScriptDatabase1"]["Characterfile_Script_fileHash"]
output_file_path = converted_dict["MNFScriptDatabase1"]["character_intro_video_path"]
download_file_System(hash,output_file_path)
# Save the video to a local file with a progress bar
if converted_dict.get('MNFScriptDatabase1', {}).get('screenplay_analysis') == "True":
hash = converted_dict["MNFScriptDatabase1"]["Screenplayh_Script_fileHash"]
output_file_path = converted_dict["MNFScriptDatabase1"]["screenplay_analysis_video_path"]
# Save the video to a local file with a progress bar
download_file_System(hash,output_file_path)
# if converted_dict.get('MNFScriptDatabase1', {}).get('characterwise_narration') == "True":
# hash = converted_dict["MNFScriptDatabase1"]["Onepager_Script_fileHash"]
# output_file_path = converted_dict["MNFScriptDatabase1"]["onepager_pdf_path"]
# download_file_System(hash,output_file_path)
print(converted_dict["MNFScriptDatabase1"])
videos_path.append(converted_dict["MNFScriptDatabase1"])
converted_dict = converted_dict["MNFScriptDatabase1"]
pq += 1
else:
pass
with open("/home/user/mnf/project/MNF/Pitchdeck/error_check1.txt","a") as file01:
file01.write("Blockchainfile: " + str(videos_path) + "\n")
return render(
request, "Pitchdeck/bundle_videos.html", {
"videos_path": videos_path, "pq": pq }
)
else:
obj = MNFScriptDatabase.objects.filter(
user_id=request.user).order_by("-date_at")
videos_path = obj
print("videos_path-??", videos_path)
pq = 0
for i in obj:
if i.elevator_pitch_video_path or i.onepager_pdf_path or i.screenplay_analysis_video_path or i.character_intro_video_path or i.line_by_line_narration_video_path or i.selected_characters or i.characterwise_video_path or i.characterwise_narration:
pq += 1
return render(
request, "Pitchdeck/bundle_videos.html", {
"videos_path": videos_path, "pq": pq}
) # many to many field or foreign key (characterwise_intro)
# pravesh-->
@login_required(login_url="/")
def view_demo_narrations(request, lang):
selected_option = lang
if selected_option is not None:
if selected_option in ["en", "hi", "mr", "fr"]:
context = {
"data": demo_files[selected_option],
"demolist": list(demo_files[selected_option])
}
return render(request, "Pitchdeck/viewDemoSampleScript.html", context)
context = {
"data": demo_files["en"],
"demolist": list(demo_files["en"])
}
t = loader.get_template('Pitchdeck/viewDemoSampleScript.html')
rendered_html = t.render({"context": context}, request)
# Extract HTML string using StringIO
html_string = StringIO()
html_string.write(rendered_html)
html_string.seek(0)
# with open('/home/user/mnf/project/MNF/Pitchdeck/yameen_html.html', 'w') as file:
# file.write(html_string.read())
# Process HTML string using BeautifulSoup
soup = BeautifulSoup(html_string, 'html.parser')
# text_elements = [element for element in soup.find_all(text=is_user_visible)]
# for i, text in enumerate(text_elements):
# print("text", text)
# trans_text = translate_comparison(text,"en", "it")
# text_elements[i].replace_with(trans_text)
modified_html = soup.prettify()
return HttpResponse(modified_html, content_type='text/html')
# return render(request, 'Pitchdeck/viewDemoSampleScript.html', context)
# def narration(request):
# sample=MNFScriptDatabase.objects.all()
# title_list = []
# path_list = []
# for i in sample:
# title_list.append(i.script_title)
# path_list.append(str(i.script_file_path.split('scripts/')[1]))
# return render(request, 'narration/narration.html',)
def delete_script(request, id):
MNFScriptDatabase.objects.get(id=id).delete()
return HttpResponseRedirect("/narration/narrations")
def demo(request):
return render(request, "narration/demo.html", {})
def Onepagerdemo(request):
return render(request, "Pitchdeck/Onepagerdemo.html", {})
def elevatorpitchdemo(request):
return render(request, "Pitchdeck/elevatorpitchdemo.html", {})
def screenplaydemo(request):
return render(request, "Pitchdeck/screenplaydemo.html", {})
def linebylinedemo(request):
return render(request, "Pitchdeck/linebylinedemo.html", {})
def Characterwisedemo(request):
return render(request, "Pitchdeck/Characterwisedemo.html", {})
def characterintrodemo(request):
return render(request, "Pitchdeck/characterintrodemo.html", {})
def narratescriptdemo(request):
return render(request, "Pitchdeck/narratescriptdemo.html", {})
def narrationroomdemo(request):
return render(request, "Pitchdeck/narrationroomdemo.html", {})
def char_function(script_id,character):
obj = Char_audio_class.char_audio(script_id, flag=True)
audio_data = obj.char_audioTTS()
obj_i =TestingC.Char_video_class(script_id)
characterdata = obj_i.char_data_written()
obj_i.new_logo()
for i in characterdata:
obj_i.first_intro_page(i)
objAV = audio_video.audio_video(audio_data,script_id,characterdata,True)
objAV.make_character_introduction(flag=True)
path = objAV.make_dialogue_clip(character)
return path
def uploadData(request):
if request.method == "POST":
# if UserCredentialsForBlockchain.objects.filter(user=request.user).exists():
# blockchain_obj = UserCredentialsForBlockchain.objects.get(user=request.user)
# print("blockchain_obj.privateKe",blockchain_obj.privateKey)
# url = "http://127.0.0.1:8005/Write/onlyOwner"
# uploadFiles = "http://127.0.0.1:5000/upload"
# data ={
# "file": request.FILES['uploadfile']
# }
# # request.FILES.get
# response =requests.post(uploadFiles,files=data)
# hash = response.json()["hash"]
# Module= "narration"
# servicesName = "PitchdeckCreation"
# print(hash)
# data1 ={
# "user_id":blockchain_obj.user_id,
# "Module": Module,
# "Services": servicesName,
# "Data": request.POST.get('textdata') ,
# "File":[hash],
# "userPrivateKey":blockchain_obj.privateKey
# }
# response =requests.post(url,json=data1)
# # video_url = decryptionOfUrl(hash)
# # response = requests.get(video_url, stream=True)
MongoDBUrl = "mongodb+srv://mynextfilm:mnf123@cluster0.ojasb.mongodb.net/myFirstDatabase?retryWrites=true&w=majority"
client = MongoClient(MongoDBUrl)
db = client.DB
users = db["auth_user"].find()
for user in users:
if "id" in user:
print(user["id"])
if UserCredentialsForBlockchain.objects.filter(user_id=user["id"]).exists():
print("user is alrady exists")
else:
accountDetail = walletCreation()
binaryToHex = accountDetail[1]
blockchain_obj = UserCredentialsForBlockchain()
blockchain_obj.user_id = user["id"]
blockchain_obj.privateKey = binaryToHex
blockchain_obj.publicKey = accountDetail[0]
blockchain_obj.save()
return render(request,"Pitchdeck/getPostdata.html")
return render(request,"Pitchdeck/getPostdata.html")
def getData(request):
if UserCredentialsForBlockchain.objects.filter(user=request.user).exists():
blockchain_obj = UserCredentialsForBlockchain.objects.get(user=request.user)
print("blockchain_obj.privateKe",blockchain_obj.privateKey)
Module= "narration"
servicesName = "PitchdeckCreation"
data ={
"private_key": blockchain_obj.privateKey,
"user_id": blockchain_obj.user_id,
"Module": Module,
"Services": servicesName,
"Project": 0,
}
response =requests.get(GET_OWNER,params=data)
getData = response.json()
with open("/home/user/mnf/project/MNF/Pitchdeck/error_check.txt","a") as file01:
file01.write("form data>>>>>>>>>>2: " + str(getData) + "\n")
# data = getData["getData"]
data1 = getData.get("getData")[1]
hash = getData.get("getData")[2][0]
_url = decryptionOfUrl(hash)
with open("/home/user/mnf/project/MNF/Pitchdeck/error_check.txt","a") as file01:
file01.write("form data>>>>>>>>>>1: " + str(data1 ) + "\n")
response11 = requests.get(_url, stream=True)
# Check if the request was successful
if response11.status_code == 200:
# Get the total size of the video in bytes
total_size = int(response11.headers.get('content-length', 0))
# Replace 'video.mp4' with the desired file path and name
output_file_path = '/home/user/mnf/project/MNF/media/Blockchaainscripts/storage.pdf'
# Save the video to a local file with a progress bar
with open(output_file_path, 'wb') as video_file, tqdm(
desc=output_file_path,
total=total_size,
unit='B',
unit_scale=True,
unit_divisor=1024,
) as progress_bar:
for data in response11.iter_content(chunk_size=1024):
video_file.write(data)
progress_bar.update(len(data))
print("Video saved successfully.")
else:
print("Failed to download the video. Status code:", response11.status_code)
url ="http://115.245.192.138/media/Blockchaainscripts/storage.docx"
return render(request,"Pitchdeck/getPostdata.html", {"url": url, "data" :data1})
# from tqdm import tqdm
# def test(request):
# data = Pitch_creation()
# result = []
# progress = 0
# total = len(data)
# for item in tqdm(data, total=total):
# result.append(process_item(item))
# progress = int(100 * len(result) / total)
# tqdm.update(progress)
# return render(request, "Pitchdeck/testfile.html",{'result': result, 'progress': progress})
# def get_samescript_data(user, script_name):
# mnf_script = MNFScriptDatabase.objects.filter(user_id=user, script_name=script_name).first()
# if mnf_script.exists():
# for i in mnf:
# if i.elevator_pitch_video_path or i.onepager_pdf_path or i.screenplay_analysis_video_path or i.character_intro_video_path or i.line_by_line_narration_video_path or i.selected_characters or i.characterwise_video_path or i.characterwise_narration:
# pitchvector_data = PitchVector.objects.filter(user_id=user, id=mnf_script.id).first()
# return pitchvector_data
# return None