Sindbad~EG File Manager

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

#engine = create_engine(app.config['DATABASE_URI'])
engine      = create_engine(app.config['DATABASE_URI'],pool_pre_ping=True,pool_recycle=3600,future=True)
engine_fk   = create_engine(app.config['DATABASE_URI_FK'],pool_pre_ping=True,pool_recycle=3600,future=True)
engine_conf = create_engine(app.config['DATABASE_URI_CONF'],pool_pre_ping=True,pool_recycle=3600,future=True)


class HallLogsModel():
	def __init__(self):
		try:
			self.meta       = MetaData()
			self.halls  = Table("halls", self.meta, autoload_with=engine)
			self.scan_logs  = Table("scan_logs", self.meta, autoload_with=engine)
		   
		except Exception as e:
			print(e)


	def gethall(self,conf_id,pin_number):
		with engine.connect() as conn:
			# stmt = text("select * from halls where conf_id =:conf_id and (entry_pin_number =:pin_number or exit_pin_number =:pin_number) and is_active = 1 ;")
			stmt = text("select * from halls where conf_id =:conf_id and (pin_number =:pin_number) and is_active = 1 ;")
			results = conn.execute(stmt.bindparams(conf_id=conf_id,pin_number=pin_number)).one_or_none()
			if results :
				return dict(results._mapping)
			else:
				return None


	def getCurrentSessionHallsModel(self,abs_session_table,conf_id,current_dt,hall_id,conf_date):
		with engine.connect() as conn:
			stmt = text("select * from "+str(abs_session_table)+" where conf_id =:conf_id and hall_id=:hall_id and dt=:conf_date and '"+current_dt+"' between starts_by and ends_by ;")
			results = conn.execute(stmt.bindparams(conf_id=conf_id,hall_id=hall_id,conf_date=conf_date))
			results=  results.one_or_none()
			if results :
				return dict(results._mapping)
			else:
				return None

	def usp_save_hall_scanned_data(self,conf_id,delegate_no,hall_id,del_table_name):
		connection  = engine_conf.raw_connection()
		cursor      = connection.cursor()
		cursor.callproc("usp_save_hall_scanned_data_v2",[conf_id,delegate_no,hall_id,del_table_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
			
	def usp_get_scan_log_reports_by_hall(self,conf_date):
		connection  = engine.raw_connection()
		cursor      = connection.cursor()
		cursor.callproc("usp_get_scan_log_reports_by_hall",[conf_date])
		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 usp_gen_scan_log_reports(self):
		connection  = engine.raw_connection()
		cursor      = connection.cursor()
		cursor.callproc("usp_gen_scan_log_reports",[])
		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 usp_generate_session_table_scan_logs(self,conf_id,hall_id):
		connection  = engine_conf.raw_connection()
		cursor      = connection.cursor()
		cursor.callproc("usp_generate_session_table_scan_logs",[conf_id,hall_id])
		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.co

	def gethallreportHallsModel(self,conf_key,abs_hall_id,current_date,asession_id):
		connection  = engine_conf.raw_connection()
		cursor      = connection.cursor()
		cursor.callproc("usp_get_hall_report_data_v1",[conf_key,abs_hall_id,current_date,asession_id])
		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 gethallsessionreportHallsModel(self,conf_key,abs_hall_id,current_date):
		connection  = engine_conf.raw_connection()
		cursor      = connection.cursor()
		cursor.callproc("usp_get_hall_session_report_data",[conf_key,abs_hall_id,current_date])
		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 getconfdatesHallModel(self,conf_id):
		with engine_conf.connect() as conn:
			stmt = text("select day(dt) as dt,display_dt,dt as idt from abs_sessions where conf_id = :conf_id group by dt order by idt;")
			results = conn.execute(stmt.bindparams(conf_id=conf_id)).all()
			return [dict(r._mapping) for r in results] if results else None
			

	def getActiveSessionHallsModel(self,abs_session_table,conf_id,hall_id,conf_date):
		with engine.connect() as conn:
			stmt = text("select * from "+str(abs_session_table)+" where conf_id =:conf_id and hall_id=:hall_id and dt=:conf_date and is_active=1 ;")
			results = conn.execute(stmt.bindparams(conf_id=conf_id,hall_id=hall_id,conf_date=conf_date))
			results=  results.one_or_none()
			if results :
				return dict(results._mapping)
			else:
				return None

	def usp_generate_scan_logs_as_active(self,conf_id,abs_hall_id):
		connection  = engine_conf.raw_connection()
		cursor      = connection.cursor()
		cursor.callproc("usp_generate_scan_logs_as_active",[conf_id,abs_hall_id])
		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 usp_generate_scan_logs_as_active_with_sync(self,conf_id,abs_hall_id):
		connection  = engine_conf.raw_connection()
		cursor      = connection.cursor()
		cursor.callproc("usp_generate_scan_logs_as_active_with_sync",[conf_id,abs_hall_id])
		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 usp_generate_scan_logs_as_closed(self,conf_id,abs_hall_id):
		connection  = engine_conf.raw_connection()
		cursor      = connection.cursor()
		cursor.callproc("usp_generate_scan_logs_as_closed",[conf_id,abs_hall_id])
		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 usp_generate_scan_logs_as_closed_with_sync(self,conf_id,abs_hall_id):
		connection  = engine_conf.raw_connection()
		cursor      = connection.cursor()
		cursor.callproc("usp_generate_scan_logs_as_closed_with_sync",[conf_id,abs_hall_id])
		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 gethallsessionreportHallsModel(self,conf_key,abs_hall_id,current_date):
		connection  = engine_conf.raw_connection()
		cursor      = connection.cursor()
		cursor.callproc("usp_get_hall_session_report_data",[conf_key,abs_hall_id,current_date])
		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

# backoffice

	def gethallsname(self,conf_id):
		conn = engine.connect()
		# stmt = text("select * from halls where conf_id =:conf_id and (entry_pin_number =:pin_number or exit_pin_number =:pin_number) and is_active = 1 ;")
		stmt = text("select * from halls where conf_id =:conf_id  ;")
		results = conn.execute(stmt.bindparams(conf_id=conf_id)).all()
		return [dict(r._mapping) for r in results] if results else None



	def usp_get_overall_session_wise_report(self,conf_id,conf_key,current_date):
		connection  = engine_conf.raw_connection()
		cursor      = connection.cursor()
		cursor.callproc("usp_get_overall_session_wise_report",[conf_id,conf_key,current_date])
		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 usp_get_overall_delegate_report(self,conf_id,conf_key):
		connection  = engine_conf.raw_connection()
		cursor      = connection.cursor()
		cursor.callproc("usp_get_overall_delegate_report",[conf_id,conf_key])
		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 usp_get_overall_hall_report(self,conf_id,conf_key,current_date,conf_date):
		connection  = engine_conf.raw_connection()
		cursor      = connection.cursor()
		cursor.callproc("usp_get_overall_hall_report",[conf_id,conf_key,current_date,conf_date])
		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 usp_get_delegate_session_wise_report(self,conf_id,conf_key,current_date_1,delegate_no):
		connection  = engine_conf.raw_connection()
		cursor      = connection.cursor()
		cursor.callproc("usp_get_delegate_session_wise_report",[conf_id,conf_key,current_date_1,delegate_no])
		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 GetConf(self,conf_id,conf_key):
		with engine.connect() as conn:
			stmt   = text("select * from conference  where conf_id = "+str(conf_id)+" and conf_key = '"+conf_key+"'  limit 1;")
			result = conn.execute(stmt)
			result = result.one_or_none()
			return dict(result._mapping) if result else None
		
	def gethallSessions(self,conf_id,abs_hall_id,current_date):
		with engine_conf.connect() as conn:
			stmt   = text(f"select asession_id,session_name,hall,dt,starts_by,ends_by from abs_sessions where conf_id = {conf_id} and hall_id = {abs_hall_id} and day(dt)='{current_date}' order by starts_by;")
			results = conn.execute(stmt).all()
			return [dict(r._mapping) for r in results] if results else None
		
	def GetSession(self,conf_id,asession_id):
		with engine_conf.connect() as conn:
			stmt   = text("select * from abs_sessions where conf_id = "+str(conf_id)+" and asession_id = "+str(asession_id)+" ;")
			result = conn.execute(stmt)
			result = result.one_or_none()
			return dict(result._mapping) if result else None

	def Gethall(self,conf_id,abs_hall_id):
		with engine.connect() as conn:
			stmt   = text("select * from halls where conf_id = "+str(conf_id)+" and abs_hall_id = "+str(abs_hall_id)+" ;")
			result = conn.execute(stmt)
			result = result.one_or_none()
			return dict(result._mapping) if result else None
	
	def usp_get_overall_hall_sessions_report_by_date(self,conf_id,conf_key,current_date,dt):
		connection  = engine_conf.raw_connection()
		cursor      = connection.cursor()
		cursor.callproc("usp_get_overall_hall_sessions_report_by_date",[conf_id,conf_key,current_date,dt])
		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 usp_save_hall_scanned_data_to_live(self,conf_id,delegate_no,hall_id,del_table_name):
		connection  = engine_conf.raw_connection()
		cursor      = connection.cursor()
		cursor.callproc("usp_save_hall_scanned_data_v2_to_live",[conf_id,delegate_no,hall_id,del_table_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