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['FC_DATABASE_URI'])

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


	def getDelegate(self,conf_id,table_name,conf_schema):
		with engine.connect() as conn:
			stmt = text(f"select delegate_id,user_id,delegate_no,conference_id,role,role_in_cert,prefix,full_name,email,mobile,updated_at from {conf_schema}.{table_name} where conference_id={conf_id};")
			results = conn.execute(stmt).all()
			return [dict(r._mapping) for r in results] if results else None
	
	def getDelegate_v1(self,conf_id,table_name,conf_schema):
		with engine.connect() as conn:
			stmt = text(f"select delegate_id,user_id,delegate_no,conference_id,role,role_in_cert,prefix,full_name,email,mobile,updated_at,ref_no from {conf_schema}.{table_name} where conference_id={conf_id};")
			results = conn.execute(stmt).all()
			return [dict(r._mapping) for r in results] if results else None
	
	def getFCSessionData(self,conf_id,table_name,conf_schema):
		with engine.connect() as conn:
			stmt = text(f"SELECT * FROM {conf_schema}.{table_name} where conf_id={conf_id};")
			results = conn.execute(stmt).all()
			return [dict(r._mapping) for r in results] if results else None
	
	def getFCSessionData(self,conf_id,table_name,conf_schema):
		with engine.connect() as conn:
			stmt = text(f"SELECT * FROM {conf_schema}.{table_name};")
			results = conn.execute(stmt).all()
			return [dict(r._mapping) for r in results] if results else None
	
	def insertSessionEntry(self,data,table_name,conf_schema):
		session_entry   = Table(table_name, self.meta, schema=conf_schema , autoload_with=engine)
		with engine.connect() as conn:
			result = conn.execute(session_entry.insert(), data)
			conn.commit()
			return "success"
	
	def getConferenceData(self,conf_id,table_name,conf_schema):
		with engine.connect() as conn:
			stmt = text("SELECT conf_id, conf_name, conf_title, conf_key, conf_schema, username, badge_login_password, society_id, is_active,"
			+" conf_start_time, conf_end_time,kc_del_session_table_name, kc_session_entry_table_name,del_table_name, fc_del_session_table_name, fc_session_entry_table_name, system_wise_scan,food_logo,kit_logo FROM "+str(conf_schema)+"."+str(table_name)+" where conf_id="+str(conf_id)+";")
			results = conn.execute(stmt).all()
			return [dict(r._mapping) for r in results] if results else None
	
	def getSystemWiseData(self,conf_id,table_name,conf_schema):
		with engine.connect() as conn:
			stmt = text(f"SELECT * FROM {conf_schema}.{table_name} where conf_id={conf_id};")
			results = conn.execute(stmt).all()
			return [dict(r._mapping) for r in results] if results else None
	
	
	def getSyncedEntryData(self,conf_id,table_name,conf_schema,session_id,last_sync_at):
		with engine.connect() as conn:
			if last_sync_at:
				timestamp = datetime.strptime(last_sync_at, '%Y-%m-%d %H:%M:%S')
				new_timestamp = timestamp - timedelta(seconds=10)
			 #   stmt = text(f"SELECT * FROM {conf_schema}.{table_name} where  session_id = {session_id} and sync_at >= '{new_timestamp}' ;")
				stmt = text(f"SELECT * FROM {conf_schema}.{table_name} where  session_id = {session_id} and sync_at >= '{last_sync_at}' ;")
			else:
				stmt = text(f"SELECT * FROM {conf_schema}.{table_name} where session_id = {session_id} ;")
			results = conn.execute(stmt).all()
			return [dict(r._mapping) for r in results] if results else None
			
	def check_conf_data(self,username,conf_key):
		with engine.connect() as conn:
			stmt = text(f"SELECT conf_id, conf_name, conf_title, conf_key, conf_schema, username, badge_login_password, society_id, is_active, conf_start_time, conf_end_time,kc_del_session_table_name, kc_session_entry_table_name,del_table_name, fc_del_session_table_name, fc_session_entry_table_name, system_wise_scan,food_logo,kit_logo FROM numerotech_primary_db.conference where username= '{username}' and conf_key= '{conf_key}' and is_active=1;")
			results = conn.execute(stmt).all()
			return [dict(r._mapping) for r in results] if results else None
	
	def get_last_updates_dele(self,conf_id,table_name,conf_schema,last_sync):
		with engine.connect() as conn:
			stmt = text(f"select delegate_id,user_id,delegate_no,conference_id,role,role_in_cert,prefix,full_name,email,mobile,updated_at from {conf_schema}.{table_name} where (updated_at > '{last_sync}' or created_at > '{last_sync}');")
			results = conn.execute(stmt).all()
			return [dict(r._mapping) for r in results] if results else None
	
	def get_last_updates_dele_v1(self,conf_id,table_name,conf_schema,last_sync):
		with engine.connect() as conn:
			stmt = text(f"select delegate_id,user_id,delegate_no,conference_id,role,role_in_cert,prefix,full_name,email,mobile,updated_at,ref_no from {conf_schema}.{table_name} where (updated_at > '{last_sync}' or created_at > '{last_sync}');")
			results = conn.execute(stmt).all()
			return [dict(r._mapping) for r in results] if results else None

	def get_last_updates_dele_map(self,conf_id,table_name,conf_schema,last_sync):
		with engine.connect() as conn:
			stmt = text(f"select * from {conf_schema}.{table_name} where (updated_at > '{last_sync}' or created_at > '{last_sync}');")
			results = conn.execute(stmt).all()
			return [dict(r._mapping) for r in results] if results else None
	
	def getDelegate_tshirt(self,conf_id,table_name,conf_schema):
		with engine.connect() as conn:
			stmt = text(f"select delegate_id,user_id,delegate_no,conference_id,role,role_in_cert,prefix,full_name,email,mobile,updated_at,tshirt_collected_at,reg_remarks from {conf_schema}.{table_name} where conference_id={conf_id};")
			results = conn.execute(stmt).all()
			return [dict(r._mapping) for r in results] if results else None
			
	def get_last_updates_dele_tshirt(self,conf_id,table_name,conf_schema,last_sync):
		with engine.connect() as conn:
			stmt = text(f"select delegate_id,user_id,delegate_no,conference_id,role,role_in_cert,prefix,full_name,email,mobile,updated_at,tshirt_collected_at,reg_remarks from {conf_schema}.{table_name} where (updated_at > '{last_sync}' or created_at > '{last_sync}');")
			results = conn.execute(stmt).all()
			return [dict(r._mapping) for r in results] if results else None
	
	def UpdateSessionEntry(self,table_name,conf_schema,now,sync_key):
		session_entry   = Table(table_name, self.meta, schema=conf_schema , autoload_with=engine)
		with engine.connect() as conn:
			stmt=text(f"UPDATE {conf_schema}.{table_name} SET sync_at = '{now}' WHERE sync_key='{sync_key}';")
# 			stmt = session_entry.update().values(now).where(session_entry.c.topic_id.in_([i["topic_id"]]))
			result = conn.execute(stmt)
			conn.commit()
			return "success"

# 	def updateTshirtScanData(self,data,table_name,conf_schema):
# 		try:
# 			with engine.connect() as conn:
# 				# data_list   = session['students']
# 				dyTable   = Table(table_name, self.meta, schema=conf_schema , autoload_with=engine)
# 				stmt        = insert(dyTable).values(data)
# 				update_dict = {key: stmt.inserted[key] for key in data if key != 'delegate_id'}
	
# 				stmt = stmt.on_duplicate_key_update(**update_dict)
				
# 				conn.execute(stmt)
				
# 				conn.commit()
				
# 			return 'success'

# 		except SQLAlchemyError as e:
# 			return f'Error inserting data: {str(e)}'	

	def delete_map_delegates(self,conf_id,table_name,conf_schema,sess_key):
		with engine.connect() as conn:
			stmt = text(f"SELECT fs.* FROM {conf_schema}.{table_name} fs inner join numerotech_conf_demo24.fc_sessions fc on fs.session_id=fc.session_id where fc.session_key={sess_key} and fc.conf_id={conf_id};")
			results = conn.execute(stmt).all()
			return [dict(r._mapping) for r in results] if results else None
		
	def updateTshirtScanData(self,data,table_name,conf_schema):
		try:
			with engine.connect() as conn:
				dyTable   = Table(table_name, self.meta, schema=conf_schema , autoload_with=engine)
				for d in data:
					stmt = dyTable.update().where(dyTable.c.delegate_id.in_([d['delegate_id']])).values(d)
					results     = conn.execute(stmt)
				conn.commit()
				
			return 'success'

		except SQLAlchemyError as e:
			return f'Error inserting data: {str(e)}'