Sindbad~EG File Manager

from sqlalchemy import create_engine, MetaData, Table, insert, select,update,delete,text
from sqlalchemy.sql import and_, or_
from core import app
import json

import datetime
 
from datetime import timedelta,date,datetime

engine    = create_engine(app.config['DATABASE_URI'],pool_recycle=3600)
engine_fk = create_engine(app.config['DATABASE_URI_FK'],pool_recycle=3600)

class FCModel():
	def __init__(self):
		try:
			self.meta = MetaData()
			self.fc_sessions = Table("fc_sessions", self.meta, autoload_with=engine_fk)  
			   
		except Exception as e:
			print(e)

	# def getFCConfData(self,conf_id,conf_key):
	# 	conn = engine.connect()
	# 	stmt =text("select * from conference where conf_id ="+str(conf_id)+" and conf_key ='"+conf_key+"';")
	# 	result = conn.execute(stmt)
	# 	conn.close()
	# 	results = [dict(r) for r in result] if result else None
	# 	if results :
	# 		return results[0]
	# 	else:
	# 		return None

	def getDataBysession_key(self,session_key,current_dt,conf_id,conf_key):
		with engine_fk.connect() as conn:
			# stmt = text("SELECT s.* from fc_sessions s where s.session_key = "+str(session_key)+ " and s.conf_id = "+ str(conf_id) + " and conf_key = '"+str(conf_key)+"' and '"+current_dt+"'  between s.start_time and s.end_time;")
			# stmt = text("select  * from fc_sessions where session_key  = '"+session_key+"' ;")
			stmt = text("SELECT s.* from fc_sessions s where s.session_key = "+str(session_key)+ " and s.conf_id = "+ str(conf_id) + " and conf_key = '"+str(conf_key)+"' ;")

			result = conn.execute(stmt).one_or_none()
			if result :
				return dict(result._mapping)
			else:
				return None

	def insertFCScannedData1(self,session_id,delegate_no,del_table_name,fc_del_session_table_name,fc_session_entry_table_name,scan_system_name):
		connection = engine_fk.raw_connection()
		cursor = connection.cursor()
		# print("sp parm : ",session_id,delegate_no,del_table_name,fc_del_session_table_name,fc_session_entry_table_name,scan_system_name)
		cursor.callproc("usp_save_fc_scanned_data",[session_id,delegate_no,del_table_name,fc_del_session_table_name,fc_session_entry_table_name,scan_system_name])
		
		if cursor.description :
			columns = [column[0] for column in cursor.description]
			results = []
			for row in cursor.fetchall():
				results.append(dict(zip(columns, row)))
			cursor.close()
			connection.commit()
			if results :
				return results
			else :
				return None
		else :
			cursor.close()
			connection.commit()
			return None	


	#single result set store proc
	def getFCReport(self,session_id,conf_id,conf_key,del_table_name,fc_session_entry_table_name,system_wise_scan,scan_system_name,role_wise_report):
		connection = engine_fk.raw_connection()
		cursor = connection.cursor()
		cursor.callproc("usp_get_fc_reports",[session_id,conf_id,conf_key,del_table_name,fc_session_entry_table_name,system_wise_scan,scan_system_name,role_wise_report])
		
		if cursor.description :
			columns = [column[0] for column in cursor.description]
			results = []
			for row in cursor.fetchall():
				results.append(dict(zip(columns, row)))
			cursor.close()
			connection.commit()
			if results :
				return results
			else :
				return None
		else :
			cursor.close()
			connection.commit()
			return None		

# check session is open
	
	def checkFCSessionIsOpen(self,session_id,current_dt):
		with engine_fk.connect() as conn:
	# 		stmt = text("SELECT s.* from fc_sessions s where s.session_id = "+str(session_id)+" and '"+current_dt+"'  between s.start_time and s.end_time;")
			stmt = text("select  * from fc_sessions where session_id  = "+str(session_id)+" ;")
			result = conn.execute(stmt).one_or_none()
			if result :
				return dict(result._mapping)
			else:
				return None

# call usp_get_kc_download_report(3,1,'fc_sessions_entry_selsi22','DELEGATE');
	# GET SCANNED RECORDS FOR DOWNLOAD REPORT #single result set store proc 
	def getFcReportDownload(self,session_id,conf_id,fc_session_entry_table_name,role,del_table_name):
		connection = engine_fk.raw_connection()
		cursor = connection.cursor()
		cursor.callproc("usp_get_fc_reports",[session_id,conf_id,conf_key,del_table_name,fc_session_entry_table_name,system_wise_scan])
		
		if cursor.description :
			columns = [column[0] for column in cursor.description]
			results = []
			for row in cursor.fetchall():
				results.append(dict(zip(columns, row)))
			cursor.close()
			connection.commit()
			if results :
				return results
			else :
				return None
		else :
			cursor.close()
			connection.commit()
			return None		



	def insert_token_data(self,insert_stmt):
		with engine_fk.connect() as conn:
			try:
				stmt = text(insert_stmt)
				results = conn.execute(stmt)
				conn.commit()
				return "success"
			except Exception as e:
				return str(e)
		
		# if conf_id and int(conf_id) == 2:
		# 	result = conn.execute(self.kc_sessions_entry_vrsi22.insert(), data)
		# if conf_id and int(conf_id) == 3:
		# 	result = conn.execute(self.kc_sessions_entry_selsi22.insert(), data) 
		# if conf_id and int(conf_id) == 4:
		# 	result = conn.execute(self.kc_sessions_entry_kos22.insert(), data)   
		# if conf_id and int(conf_id) == 6:
		# 	result = conn.execute(self.kc_sessions_entry_rscon2022.insert(), data) 
		# if conf_id and int(conf_id) == 12:
		# 	result = conn.execute(self.kc_sessions_entry_karavali22.insert(), data)  
		# if conf_id and int(conf_id) == 14 :
		#     result = conn.execute(self.kc_sessions_entry_respicon22.insert(), data)	
			
		# return "success"	
# 	def insert_token_data(self,data,conf_id):
# 		conn = engine.connect()
# 		if conf_id and int(conf_id) == 2:
# 			result = conn.execute(self.fc_sessions_entry_vrsi22.insert(), data)
# 		if conf_id and int(conf_id) == 3:
# 			result = conn.execute(self.fc_sessions_entry_selsi22.insert(), data) 
# 		if conf_id and int(conf_id) == 4:
# 			result = conn.execute(self.fc_sessions_entry_kos22.insert(), data)   
# 		if conf_id and int(conf_id) == 6:
# 			result = conn.execute(self.fc_sessions_entry_rscon2022.insert(), data) 
# 		if conf_id and int(conf_id) == 12:
# 			result = conn.execute(self.fc_sessions_entry_karavali22.insert(), data)
# 		if conf_id and int(conf_id) == 14 :
# 		    result = conn.execute(self.fc_sessions_entry_respicon22.insert(), data)
			
# 		conn.close()
# 		return "success"			

	# get completed sessions
	def completedSessions(self,conf_id,current_dt_1):	
		with engine_fk.connect() as conn:
			stmt = text("SELECT s.* from fc_sessions s where s.conf_id = "+str(conf_id)+" and s.end_time < '"+current_dt_1+"' ;")
			#stmt = text("select  * from kc_sessions where session_key  = '"+session_key+"' ;")
			result = conn.execute(stmt).one_or_none()
			if result :
				return dict(result._mapping)
			else:
				return None

	#######################
	
	# def insertScannedData(self,data,session_id,delegate_no,del_table_name,fc_del_session_table_name,fc_session_entry_table_name):
	# 	conn = engine.connect()
	# 	# check delegate_no exists for sessions in our delegate table
	# 	stmt_1 = text("SELECT ds.delegate_session_id,ds.delegate_no,ds.session_id,d.full_name,d.role from "+fc_del_session_table_name+" ds "
	# 		+"inner join "+del_table_name+" d on d.delegate_no = ds.delegate_no  " 
	# 		+"where ds.delegate_no ="+str(delegate_no)+"  and ds.session_id = "+str(session_id)+" ;")
	# 	result_1 = conn.execute(stmt_1)
	# 	result = result_1.fetchone()
	# 	if result  :
	# 		full_name = result.full_name
	# 		role = result.role

	# 		# check already scanned 
	# 		stmt = text("SELECT * FROM "+fc_session_entry_table_name+" where delegate_no = "+str(delegate_no) +" and session_id = " +str(session_id) + " ;" )
	# 		results  = engine.execute(stmt)
	# 		already_scanned = results.fetchone()
	# 		if already_scanned :
	# 			conn.close()
	# 			scan_at = already_scanned.created_at
	# 			scan_at = scan_at.strftime("%d/%m/%Y %H:%M:%S")
	# 			data = {"delegate_no" :delegate_no, "full_name" : full_name ,"role" : role , "scan_at" : scan_at,"msg" : "ALREADY REGISTERED WITH US" ,"status" : 3}
	# 		else :
	# 			now = datetime.now()
	# 			current_dt_1  = now.strftime("%Y-%m-%d %H:%M:%S")
	# 			insert_stmt = text("insert into "+fc_session_entry_table_name+" (delegate_no,created_at,session_id) values ("+str(delegate_no)+",'"+current_dt_1+"',"+str(session_id)+");")
	# 			# if delegate no exist in delegate table and not scanned then save record in session entry table
	# 			result = conn.execute(insert_stmt)
	# 			conn.close()
	# 			data = {"delegate_no" : delegate_no,"full_name" : full_name ,"role" : role , "scan_at" : "" ,"msg" : "REGISTERED" ,"status" : 1}
	# 	else :
	# 		data = {"delegate_no" : delegate_no, "full_name" : "" ,"role" : " ","scan_at" : "" ,"msg" : "NOT REGISTERED WITH US" ,"status" : 2}

	# 	json_data = json.dumps(data ,default =str)	
	# 	return json_data					
	
	
	
	def getDataBysession_keyFrontEnd(self,session_key,current_dt,conf_id,conf_key):
		with engine_fk.connect() as conn:
			stmt = text("SELECT s.* from fc_sessions s where s.session_key = "+str(session_key)+ " and s.conf_id = "+ str(conf_id) + " and conf_key = '"+str(conf_key)+"' and '"+current_dt+"'  between s.start_time and s.end_time;")
			# stmt = text("SELECT s.* from fc_sessions s where s.session_key = "+str(session_key)+ " and s.conf_id = "+ str(conf_id) + " and conf_key = '"+str(conf_key)+"' ;")
			result = conn.execute(stmt)
			result = result.one_or_none()
			return dict(result._mapping) if result else None
			
	def getFcScanErrorLogs(self,conf_id,conf_key,curr_date,is_column_only):
		with engine.connect() as conn :
			if is_column_only   == 0 :
				stmt = text("select id,url,message,host_url,scan_updated_at,date_format(created_at , '%d-%m-%Y,%H:%i:%s') as created_on,conf_id from numerotech_primary_db.logs where url like '%/post_fc_scan_data?conf_id="+str(conf_id)+"%' "
					+ " and host_url = 'conferencescan.numerotech.com' and date(created_at) = '"+curr_date+"' "
					+ " and scan_updated_at is null  order by id desc  limit 50 ;")	

				result  = conn.execute(stmt).all()
				results = [dict(r._mapping) for r in result] if result else None
				if results :
					return results if results else None
			else :
				stmt_2   = text("select conf_id,del_table_name,fc_del_session_table_name,kc_del_session_table_name,kc_session_entry_table_name,fc_session_entry_table_name  from conference where conf_id ="+str(conf_id)+" and conf_key = '"+conf_key+"'  limit 1;")
				result_1 = conn.execute(stmt_2).one_or_none()
				result_1 = dict(result_1._mapping) if result_1 else None
				return result_1


	def saveFCScanDataFromLogs(self,ids, data):
		with engine.connect() as conn:
			stmt      = self.logs.update().where(self.logs.c.id.in_(ids)).values(data)
			restult_1 = conn.execute(stmt)
			conn.commit()
		return "success"	
		
	def scanSystemName(self,conf_id) :
		with engine_fk.connect() as conn:
			stmt    = text("select * from system_wise_scan where conf_id = "+str(conf_id)+" and is_active = 1  order by system_id;")					
			result  = conn.execute(stmt).all()
			results = [dict(r._mapping) for r in result] if result else None
			return results