Sindbad~EG File Manager

from flask import Flask, request, Blueprint, jsonify, redirect, url_for,flash, render_template,session, app
from core.model.UserModel import UserModel
from core.model.AbstractModel import AbstractModel
from core.model.BoModel import BoModel
from random import randint
import datetime
from core.library.email import EMAIL
from datetime import timedelta,date,datetime
from core.library.cryptography import Cryptography
from core.library.route_group import RouteGroup
from core.library.auth import Auth
import ast
# import collections
from urllib.parse import unquote
from collections import defaultdict

#name : Mukesh kumar
#version : 1
#title: abstract submission
#date:07/02/2022 01:14

class PPController():
	
	def AbstractsIndex(abs_type,conf_id,conf_key):                                                
		society_id = Auth.get_conference(conf_id).get("society_id")
		user_id = Auth.get_user(society_id).get('user_id')
		confe_id      = Auth.get_conference(conf_id).get('conf_id')
		data          = UserModel().get_abstract_home(user_id,abs_type,confe_id)
		my_abstracts  = data[0]
		eng_abstracts = data[1]
		validation    = AbstractModel().abstract_home_validation('PP',user_id,confe_id)
		if(validation["status"] != 1):
			flash(validation["msg"])
		return render_template('users/TNASI/PP/abstract.html',data=my_abstracts,abs_type='PP',data1=eng_abstracts,data2 = validation,lent=len(my_abstracts),conf_id=conf_id,conf_key=conf_key)

	def main_layout(abs_type,abs_id,conf_id,conf_key):
		# abs_id   = Cryptography.decrypt(abs_id)
		return render_template('users/TNASI/PP/main_PP.html',abs_type=abs_type,abs_id=abs_id,conf_id=conf_id,conf_key=conf_key)

	def New(abs_type,conf_id,conf_key):
		society_id = Auth.get_conference(conf_id).get("society_id")
		user_id = Auth.get_user(society_id).get('user_id')
		validation   = AbstractModel().abstract_home_validation(abs_type,user_id,conf_id)
		if validation["status"] == 1:
			created_at = datetime.now()
			result   = UserModel().new_abs(user_id,abs_type,34,created_at,conf_id)
			abs_id   = Cryptography.encrypt(int(result[0]))
			return abs_id
		else:
			return redirect(url_for('main.AbstractsIndex',abs_type=abs_type,conf_id=conf_id,conf_key=conf_key))

	def Step1(abs_type,conf_id,conf_key):
		json = {'msg':'','status' : 1,'data':''}
		abs_id      =   request.values.get('abs_id')
		abs_id      =   unquote(abs_id)
		abs_id      =   int(Cryptography.decrypt(abs_id))
		society_id = Auth.get_conference(conf_id).get("society_id")
		user_id = Auth.get_user(society_id).get('user_id')
		user_info   =   UserModel().get_users_member_no(user_id)#getting name and membership for the user_id
		if(abs_id > 0):
			abstract_info  =  AbstractModel().get_abstracts_by_user_abs_id(user_id,abs_id)#getting abstract info from abstract table
			if abstract_info == [] :
				json = {'msg':'Abstract Not Found<a href="'+ request.host_url + url_for('DB.Dashboard',conf_id=conf_id,conf_key=conf_key) +'"> click here to Home Page</a>','status' : 0,'data':''}
				return jsonify(json)	
			if (abstract_info["abs_status_id"] == 0):
				type_of_presentation  =  AbstractModel().get_type_of_presentation(conf_id)#getting presenting type from DB for PP
				categories            =  UserModel().get_categories(abs_type,conf_id)
				abs_id   = Cryptography.encrypt(abs_id)
				json['data'] = render_template('users/TNASI/PP/step1.html',user_info=user_info,abs_id=abs_id,abs_type=abs_type,data=abstract_info,categories=categories,type_of_presentation=type_of_presentation,conf_id=conf_id,conf_key=conf_key)
				return jsonify(json)
			else:
				json = {'msg':'Abstract already submitted<a href="'+ request.host_url + url_for('DB.Dashboard',conf_id=conf_id,conf_key=conf_key) +'"> click here to Home Page</a>','status' : 0,'data':''}
				return jsonify(json)
		else:
			return redirect(url_for('main.AbstractsIndex',abs_type=abs_type,conf_id=conf_id,conf_key=conf_key))

	def Step1post(abs_type,conf_id,conf_key):
		json = {'msg':'','status' : 0,'data':''}
		society_id = Auth.get_conference(conf_id).get("society_id")
		user_id = Auth.get_user(society_id).get('user_id')
		pa_user_id= request.values.get('pa_user_id')
		abs_id    = request.values.get('abs_id')

		abs_id    = int(Cryptography.decrypt(abs_id))
		
		if request.method == "POST":
			if pa_user_id  and int(pa_user_id) > 0:
				PA_count    = AbstractModel().get_FP_PA_count(pa_user_id,abs_id,abs_type) #count the presenting author count to check with count from settings
				settings    = AbstractModel().settings(abs_type,conf_id) #taking count form settings table to check the count of presenting author
				if(PA_count < int(settings[0][0]["setting_value"])):
					data = {
					'presentation_type_id':request.values["presenting_type"],
					# 'category_id'         :request.values["cat_type"],
					}
					step1update = UserModel().update_step(data,abs_id)#updataing the data for step1
					abs_id      = Cryptography.encrypt(int(abs_id))
					return redirect(url_for('main.Step2',abs_id=abs_id,abs_type=abs_type,conf_id=conf_id,conf_key=conf_key))
				else:
					flash('The presenting author can not participate more than '+settings[0][0]["setting_value"])
					abs_id = Cryptography.encrypt(int(abs_id))
					return redirect(url_for('main.Step1',abs_id=abs_id,abs_type=abs_type,conf_id=conf_id,conf_key=conf_key))
			else:
				json['msg'] = 'please select presenting author'
				json['status'] = 0			
				return jsonify(json)
		else:
			abs_id = Cryptography.encrypt(int(abs_id))
			return redirect(url_for('main.Step1',abs_id=abs_id,abs_type=abs_type,conf_id=conf_id,conf_key=conf_key))

	def Step2(abs_type,conf_id,conf_key):
		json = {'msg':'','status' : 1,'data':''}

		abs_id     = request.values.get('abs_id')
		abs_id     = int(Cryptography.decrypt(abs_id))
		society_id = Auth.get_conference(conf_id).get("society_id")
		user_id = Auth.get_user(society_id).get('user_id')
		step2data  = UserModel().steps_data(abs_id)#get date from DB
		if step2data == [] :
				json = {'msg':'Abstract Not Found<a href="'+ request.host_url + url_for('DB.Dashboard',conf_id=conf_id,conf_key=conf_key) +'"> click here to Home Page</a>','status' : 0,'data':''}
				return jsonify(json)	
		if(step2data['abs_status_id'] == 0 ):
			abs_id = Cryptography.encrypt(abs_id)
			json["data"] = render_template('users/TNASI/PP/step2.html',data=step2data,abs_id=abs_id,abs_type=abs_type,conf_id=conf_id,conf_key=conf_key)
			return jsonify(json)
		else:
			json = {'msg':'Abstract already submitted<a href="'+ request.host_url + url_for('DB.Dashboard',conf_id=conf_id,conf_key=conf_key) +'"> click here to Home Page</a>','status' : 0,'data':''}
			return jsonify(json)

	def StepPost_2(abs_type,conf_id,conf_key):
		if request.method == "POST":
			abs_id   = request.values["abs_id"]
			user_id  = request.values["user_id"]
			is_next  = request.values.get('is_next')
			if (int(is_next) == 1):
				abs_id   = int(Cryptography.decrypt(abs_id))
				data     = {
				'title'       :request.values.get("title" or ''),
				'synopsis' :request.values.get("synopsis" or ''),
				# 'purpose'     :request.values.get("Purpose" or ''),
				# 'methods'     :request.values.get("methods"or ''),
				# 'results'     :request.values.get("Result" or ''),
				# 'conclusion'  :request.values.get("Conclusion" or ''),
				'updated_at'  :datetime.now()   
				}
				step2data = UserModel().update_step(data,abs_id)#updating data to DB
				abs_id    = Cryptography.encrypt(int(abs_id))
				return redirect(url_for('main.Step3',abs_id=abs_id,abs_type=abs_type,conf_id=conf_id,conf_key=conf_key))
			else:
				return redirect(url_for('main.Step1',abs_id=abs_id,abs_type=abs_type,conf_id=conf_id,conf_key=conf_key))
		else:
			return None

	def Step3(abs_type,conf_id,conf_key):
		json = {'msg':'','status' : 1,'data':''}
		society_id = Auth.get_conference(conf_id).get("society_id")
		user_id = Auth.get_user(society_id).get('user_id')
		abs_id     = request.values.get('abs_id')
		abs_id     =    int(Cryptography.decrypt(abs_id))
		step2data  =    UserModel().steps_data(abs_id)#get date from DB
		if step2data == [] :
				json = {'msg':'Abstract Not Found<a href="'+ request.host_url + url_for('DB.Dashboard',conf_id=conf_id,conf_key=conf_key) +'"> click here to Home Page</a>','status' : 0,'data':''}
				return jsonify(json)
		if(step2data['abs_status_id'] == 0 ):
			abs_id = Cryptography.encrypt(int(abs_id))
			json["data"] = render_template('users/TNASI/PP/step3.html',data = step2data,abs_id=abs_id,abs_type=abs_type,conf_id=conf_id,conf_key=conf_key)
			return jsonify(json)
		else:
			json = {'msg':'Abstract already submitted<a href="'+ request.host_url + url_for('DB.Dashboard',conf_id=conf_id,conf_key=conf_key) +'"> click here to Home Page</a>','status' : 0,'data':''}
			return jsonify(json)

	def Step3post(abs_id,abs_type,conf_id,conf_key):
		abs_id      =   unquote(abs_id)
		abs_id1     =   int(Cryptography.decrypt(abs_id))
		is_next     =   request.values.get('is_next')
		if (int(is_next) == 1):
			data    = {
			'is_award':request.values.get("rdnaward" or '')
				}
			step3data=UserModel().update_step(data,abs_id1)
			return redirect(url_for('main.Step4',abs_id = abs_id,abs_type=abs_type,conf_id=conf_id,conf_key=conf_key))
		else:
			return redirect(url_for('main.Step2',abs_id=abs_id,abs_type=abs_type,conf_id=conf_id,conf_key=conf_key))

	def Searchauthor(abs_type,conf_id,conf_key):
		searchtext  = request.values["searchtext"]
		btn_val     = request.values["btn_val"]
		conf_id     = request.values["conf_id"]
		society_id  = Auth.get_conference(conf_id).get("society_id")
		role_id     = 35 
		if int(btn_val) == 0:
			setting_key = 'PP_PA_COUNT'
			data1       = AbstractModel().settings(setting_key,conf_id)#get settings for PP presenting author count
			if (data1[0]):
				data1 = data1=int(data1[0][0]["setting_value"])
			data      = UserModel().get_search_data_presenting('11,12,13,14,15,16,2',searchtext,role_id,abs_type,society_id)#getting search data from DB to step3
			html      = render_template('users/TNASI/PP/presenting_authour_search_table.html',data=data,data1=data1) 
			return jsonify(html)
		else:
			setting_key = 'PP_CA_COUNT'
			data1       = AbstractModel().settings(setting_key,conf_id)#get settings for PP presenting author count
			if (data1[0]):
				data1 = data1=int(data1[0][0]["setting_value"])
			data      = UserModel().get_search_data(searchtext,role_id,abs_type,society_id)#getting search data from DB to step3
			html      = render_template('users/TNASI/PP/co_authour_search_table.html',data=data,data1=data1) 
			return jsonify(html)
		

	def Add_update_Presenting_author(abs_type,conf_id,conf_key):
		user_id   = request.values["user_id"]
		abs_id    = request.values["abs_id"]
		role_id   = request.values["role_id"]
		add_PA = UserModel().get_user_data(user_id)#getting user data
		data   = AbstractModel().add_to_presenting_author(abs_id,user_id,role_id)#adding presenting author for PP
		html   = render_template('users/TNASI/PP/presenting_authour_table.html',pa_data=add_PA)
		return jsonify(html)

	def Add_update_co_author(abs_type,conf_id,conf_key):
		user_id     = request.values["user_id"]
		abs_id      = request.values["abs_id"]
		role_id     = request.values["role_id"]
		addcoauthor = UserModel().get_user_data(user_id)#getting user data
		abs_id      = (int(Cryptography.decrypt(abs_id)))
		saved_to    = AbstractModel().add_to_presenting_author(abs_id,user_id,role_id)#adding presenting author for PP
		html        = render_template('users/TNASI/PP/co_athour_table.html',co_data=addcoauthor)
		return jsonify(html)

	def Step1_get_author(abs_type,conf_id,conf_key):
		abs_id    = request.values["abs_id"]
		data      = AbstractModel().FP_step1_get_author(abs_id)#getting the presenting author to show in step1
		if(data == []):
			data1 = 0
			return jsonify(data1)
		html = render_template('users/TNASI/PP/presenting_authour_table.html',pa_data=data)
		return jsonify(html)

	def Get_co_author(abs_type,conf_id,conf_key):
		conf_id     =  request.values["conf_id"]
		abs_id      =  request.values["abs_id"]
		abs_id      =  int(Cryptography.decrypt(abs_id))
		data        =  AbstractModel().get_authors(abs_id)#geting author to show in step 3 table
		limit_of_authors = AbstractModel().limit_of_authors(abs_id)#geting count of author for co-authors
		settings    = AbstractModel().settings(abs_type+"_CA_COUNT",conf_id)
		if(limit_of_authors >= int(settings[0][0]["setting_value"])):
			limit   = 0
		else:
			limit   = 1
		html = render_template('users/TNASI/PP/co_athour_table.html',co_data=data,limit=limit)
		return jsonify(html)

	def Step4(abs_id,abs_type,conf_id,conf_key):
		json = {'msg':'','status' : 1,'data':''}
		abs_id              = unquote(abs_id)
		abs_id              = int(Cryptography.decrypt(abs_id))
		society_id = Auth.get_conference(conf_id).get("society_id")
		user_id = Auth.get_user(society_id).get('user_id')
		stepsdata           = AbstractModel().get_sept4_data(abs_id)#getting user and abstract data
		check_authors_count = AbstractModel().check_authors_count(abs_id,36)#this is used for step3 co-author count for VT AND PP
		if stepsdata == [] :
				json = {'msg':'Abstract Not Found<a href="'+ request.host_url + url_for('DB.Dashboard',conf_id=conf_id,conf_key=conf_key) +'"> click here to Home Page</a>','status' : 0,'data':''}
				return jsonify(json)
		if(stepsdata["abs_status_id"] == 0 ):
			if(check_authors_count["authors_count"] >= 0 ):
				co_author             =  AbstractModel().get_authors(abs_id)#geting co authors
				presenting_author     =  AbstractModel().FP_step1_get_author(abs_id)#getting presenting author
				# get_mem_count         =  AbstractModel().get_member_type_count(abs_id)
				get_mem_count         = 1
				abs_id                =  Cryptography.encrypt(int(abs_id))
				json["data"] = render_template('users/TNASI/PP/step5.html',abs_type=abs_type,abs_id=abs_id,data = stepsdata,data2=presenting_author,data1=co_author,conf_id=conf_id,conf_key=conf_key)
				if int(get_mem_count) < 1:
					# json["msg"] = "Atleast one of the authors (presenting author / Co-author) should be a ratified member to submit a paper presentation. click here to <a href='#' onclick='location.reload()'> edit your abstract </a>"
					json["msg"] = "Atleast one of the authors (presenting author / Co-author) should be a ratified member to submit a paper presentation."
					json["status"] = 0
					return jsonify(json)
				else:
					return jsonify(json)
			else:
				json["msg"] = 'Enter at least one author'
				json["status"] = 0
				return jsonify(json)
				
		else:
			json = {'msg':'Abstract already submitted<a href="'+ request.host_url + url_for('DB.Dashboard',conf_id=conf_id,conf_key=conf_key) +'"> click here to Home Page</a>','status' : 0,'data':''}
			return jsonify(json)
			
	def Mail(abs_id,conf_id,conf_key):
		society_id = Auth.get_conference(conf_id).get("society_id")
		user_id = Auth.get_user(society_id).get('user_id')
		abs_id      =   unquote(abs_id)
		abs_id     = int(Cryptography.decrypt(abs_id))
		data       = AbstractModel().get_sept4_data(abs_id)
		authors    = AbstractModel().get_authors(abs_id)
		is_next  = request.values.get('is_next')
		if (int(is_next) == 1):
			if(data["status_check"] == 0):
				data1    = {
						   'submitted_at' :  str(datetime.now()),
						   }
				PA_count = AbstractModel().get_FP_PA_count_final(abs_id,data["abs_type"])#checking presenting author count
				data2    = AbstractModel().FP_step1_get_author(abs_id)#getting presenting author details
				data3    = AbstractModel().fp_authors_for_email(abs_id)#getting co authors details
				settings = AbstractModel().settings('PP_PA_COUNT',conf_id)
				if(PA_count <= int(settings[0][0]["setting_value"])):
					output = AbstractModel().abstract_submited(user_id,abs_id,data["abs_type"],data1,conf_id)
					data       = AbstractModel().get_sept4_data(abs_id)
					confe_logo = Auth.get_conference(conf_id).get('mail_header_logo')
					for i in data3:
						name    = i["full_name"]
						subject = Auth.get_conference(conf_id).get('conf_name')+"-"+data["abs_type"]+str(data["abs_no"])+" successfully submitted"
						email   = i["email"]
						html    = render_template('users/email/TNASIpp_submit.html',name=name,data=data,data1=authors,data2=data2,confe_logo = confe_logo,conf_id=conf_id)
						now     = datetime.now()
						EMAIL.sendMail(subject,html,email,conf_id)
					# return(html)
				else:
					abs_id = Cryptography.encrypt(int(abs_id))
					flash('The presenting author can not participate more than '+settings[0][0]["setting_value"])
					return redirect(url_for('main.AbstractsIndex',abs_type=data["abs_type"],conf_id=conf_id,conf_key=conf_key))
				if output == "success":
					abs_id  = Cryptography.encrypt(int(abs_id))
					user_id = Cryptography.encrypt(int(user_id))
					return redirect(url_for('main.success',abs_type=data["abs_type"],abs_id=abs_id,user_id=user_id,conf_id=conf_id,conf_key=conf_key))
			else:
				flash('This '+data["abs_type"]+str(data["abs_no"])+' is already submitted')
				return redirect(url_for('main.AbstractsIndex',abs_type=data['abs_type'],conf_id=conf_id,conf_key=conf_key)) 
		else:
			abs_id = Cryptography.encrypt(int(abs_id))
			return redirect(url_for('main.Step3',abs_id=abs_id,abs_type=data['abs_type'],conf_id=conf_id,conf_key=conf_key))
			
	def success(abs_type,abs_id,user_id,conf_id,conf_key):
		abs_id        = unquote(abs_id)
		user_id       = unquote(user_id)
		abs_id        = int(Cryptography.decrypt(abs_id))
		user_id       = int(Cryptography.decrypt(user_id))
		authors       = AbstractModel().get_authors(abs_id)
		data          = AbstractModel().get_abstracts_by_user_abs_id(user_id,abs_id)
		alert_class   = "alert-success"
		alert_image   = "/static/images/wrong.png"
		alert_message = "Congratulations! your "+ data["abs_type"] + str(data["abs_no"]) +" is submitted successfully "
		return render_template('users/TNASI/PP/error_success.html',alert_class=alert_class,alert_message=alert_message,abs_id=abs_id,data=data,data2=authors,alert_image=alert_image,conf_id=conf_id,conf_key=conf_key)


	def View(abs_id,conf_id,conf_key):
		abs_id   = unquote(abs_id)	
		abs_id   = int(Cryptography.decrypt(abs_id))
		data     = AbstractModel().get_sept4_data(abs_id)
		data1    = AbstractModel().get_authors(abs_id)
		data2    = AbstractModel().FP_step1_get_author(abs_id)
		return render_template('users/TNASI/PP/view.html',abs_id=abs_id,data=data,data2=data2,data1=data1,conf_id=conf_id,conf_key=conf_key)