Sindbad~EG File Manager

from sqlalchemy import create_engine, MetaData, Table, insert, 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'],pool_size=5000,pool_pre_ping=True,pool_recycle=3600)
engine = create_engine(app.config['DATABASE_URI'],
					pool_size=10,        # Maximum number of connections in the pool
					max_overflow=5,      # Maximum number of additional connections to be created if pool is exhausted
					pool_timeout=30,     # Seconds to wait before giving up when trying to connect to the pool
					pool_recycle=3600,   # Time in seconds after which a connection will be recycled
				)



class AdminModel():
	def __init__(self):
		try:
			self.meta                   = MetaData()
			self.users                  = Table("users", self.meta,  autoload_with=engine)
			self.societies              = Table("societies", self.meta,  autoload_with=engine)
			self.m_attachment_type      = Table("m_attachment_type", self.meta,  autoload_with=engine)
			self.admin_access           = Table("admin_access", self.meta,  autoload_with=engine)
			self.m_app_type             = Table("m_app_type", self.meta,  autoload_with=engine)
		   
		except Exception as e:
			print(e)
		
	def get_admin_data(self,society_id):
		with engine.connect() as conn:
			stmt = text("select aa.admin_access_id,aa.admin_role_id,mar.role,aa.society_id,aa.conf_id,group_concat(aa.app_type_id) as app_type_id,u.user_id,aa.admin_email,concat(ifnull(u.prefix,''), u.full_name) as full_name, group_concat(mat.app_name) as app_name from admin_access aa "+
						"inner join users u on aa.admin_email=u.email and aa.society_id=u.society_id "+
						"left join m_app_type mat on mat.app_type_id = aa.app_type_id "+
						"left join m_admin_role mar on mar.admin_role_id = aa.admin_role_id "+
						f"where aa.society_id={society_id} "+
						"group by aa.admin_email order by admin_access_id")
			results = conn.execute(stmt).all()
			results = [dict(r._mapping) for r in results] if results else None
			conn.close()
			return results
		
	def get_admin_roles(self):
		with engine.connect() as conn:
			stmt = text("select * from m_admin_role;")
			result = conn.execute(stmt).all()
			results = [dict(r._mapping) for r in result] if result else None
			conn.close()
			return results
		
	def get_app_by_admin_email(self,society_id,admin_email):
		with engine.connect() as conn:
			stmt = text("select concat(ifnull (u.prefix,''),u.full_name)as full_name,u.mobile,u.password,ua.admin_access_id,ua.admin_role_id,a.app_type_id,s.society_id, ifnull(s.conf_id,0) as conf_id, app_name,c.conf_name,concat(a.app_type_id,'-',s.society_id,'-',ifnull(s.conf_id,0)) as access_key ,ua.admin_email from m_app_type a "+
							"inner join society_applications  s on s.app_type_id = a.app_type_id "+
							"left join conference c on c.conf_id = s.conf_id "+
							f"left join admin_access ua on ua.society_id=s.society_id and ifnull(ua.conf_id,0) = ifnull(s.conf_id,0) and ua.app_type_id=s.app_type_id and ua.admin_email='{admin_email}' "+
							f"left join users u on u.email = '{admin_email}'  and u.society_id=s.society_id "
							f"where s.society_id = {society_id} and a.app_type_id not in (9) "+
							"order by field(a.app_type_id,1,4,7,2,3,5) ,year(c.conf_start_time);")
			results = conn.execute(stmt).all()
			results = [dict(r._mapping) for r in results] if results else None
			conn.close()
			return results
		
	def get_admin_data_by_admin_email(self,society_id,admin_email):
		with engine.connect() as conn:
			stmt = text("select u.prefix,u.full_name,u.email as u_email,u.mobile,u.password,aa.admin_role_id,aa.admin_email,u.user_id from users u "+
						"left join admin_access aa on aa.admin_email=u.email and aa.society_id =u.society_id "
						f"where u.society_id={society_id} and u.email='{admin_email}' group by u_email;")
			result = conn.execute(stmt).all()
			results = [dict(r._mapping) for r in result] if result else None
			conn.close()
			return results
		
	# def get_admin_data_by_admin_email(self,society_id,admin_email):
	# 	with engine.connect() as conn:
	# 		stmt = text("select aa.admin_access_id,aa.admin_role_id,aa.admin_email,u.user_id from admin_access aa "+
	# 		   "inner join users u on u.email=aa.admin_email "+
	# 		    f"where aa.society_id = {society_id} and aa.admin_email='{admin_email}' group by admin_email")
	# 		result = conn.execute(stmt).all()
	# 		results = [dict(r._mapping) for r in result] if result else None
	# 		return results
		
	def get_old_app_datas(self,admin_email,society_id):
		with engine.connect() as conn:
			stmt = text("select admin_role_id,concat(app_type_id,'-',society_id,'-',ifnull(conf_id,0))as app_type_ids from admin_access "+ 
						f"where society_id={society_id} and admin_email='{admin_email}';")
			results = conn.execute(stmt).all()
			results = [dict(r._mapping) for r in results] if results else None
			conn.close()
			return results
		
	def insert_admin_access(self,apps):
		with engine.connect() as conn:
			stmt_1 = insert(self.admin_access).values(apps)
			result = conn.execute(stmt_1)
			conn.commit()
			conn.close()
			return result
		
	def delete_admin_access(self,delete_apps):
		with engine.connect() as conn:
			for i in delete_apps:
				where_con = ""
				if i["conf_id"]:
					where_con = " and conf_id =  "+str(i["conf_id"])
				stmt_1 = text(f"delete from admin_access where society_id = {i['society_id']} and app_type_id = {i['app_type_id']} and admin_email = '{i['admin_email']}' and admin_role_id = {i['admin_role_id']} {where_con}")
			# stmt_1 = insert(self.admin_access).values(delete_apps)
				result = conn.execute(stmt_1)
				conn.commit()
			conn.close()
			return result
		
	def insert_super_admin(self,data):
		with engine.connect() as conn:
			stmt_1 = insert(self.admin_access).values(data)
			result = conn.execute(stmt_1)
			conn.commit()
			conn.close()
			return result
		
	def delete_super_admin(self,data1):
		with engine.connect() as conn:
			stmt_1 = text(f"delete from admin_access where society_id = {data1['society_id']}  and admin_email = '{data1['admin_email']}' and admin_role_id = {data1['admin_role_id']}")
			# stmt_1 = insert(self.admin_access).values(delete_apps)
			result = conn.execute(stmt_1)
			conn.commit()
			conn.close()
			return result
		
	def insert_new_access_admin(self,data):
		with engine.connect() as conn:
			result = conn.execute(self.admin_access.insert(), data)
			conn.commit()
			conn.close()
			pk_id = result.inserted_primary_key[0] if result.inserted_primary_key[0] else None
			return pk_id
		
	def insert_admin_user(self,data):
		with engine.connect() as conn:
			result = conn.execute(self.users.insert(), data)
			conn.commit()
			conn.close()
			return result
		
	def delete_admin_access_by_email(self,data):
		with engine.connect() as conn:
			stmt_1 = text(f"delete from admin_access where society_id = {data['society_id']}  and admin_email = '{data['admin_email']}' ")
			# stmt_1 = insert(self.admin_access).values(delete_apps)
			result = conn.execute(stmt_1)
			conn.commit()
			conn.close()
			return result
		
	def update_user_data(self,user_id,data):
		with engine.connect() as conn:
			stmt = self.users.update().where(self.users.c.user_id.in_([user_id])).values(data)
			result = conn.execute(stmt)
			conn.commit()
			conn.close()
			return "success"
		
	def count_mobile_num(self,user_id,mobile,society_id):
		with engine.connect() as conn:
			stmt = text(f"select count(*) from users where user_id <> {user_id} and (mobile= '{mobile}' or whatsapp_number='{mobile}') and society_id={society_id};")
			result = conn.execute(stmt)
			conn.close()
			results = result.fetchone()
			if results :
				return results
			else:
				return None
		
	# def insert_admin_access(self,app_type_ids,society_ids,conf_ids,user_id):
	# 	with engine.connect() as conn:
	# 		row_val = []
	# 		for i in app_type_ids:
	# 			row_val.append({'category_id':i,'user_id':user_id})

	# 		stmt_1 = insert(self.users_participate_sections).values(row_val)
	# 		result = conn.execute(stmt_1)
	# 		conn.commit()
	# 		return result
		
	# def get_app_data(self,society_id):
	# 	with engine.connect() as conn:
	# 		stmt = text("select a.app_type_id,s.society_id, ifnull(s.conf_id,0) as conf_id, app_name,c.conf_name from m_app_type a "+
	# 					  "inner join society_applications  s on s.app_type_id = a.app_type_id "+
	# 					  "left join conference c on c.conf_id = s.conf_id "+
	# 					  f"where s.society_id = {society_id} and a.app_type_id not in (9) "+
 	# 					  "order by field(a.app_type_id,1,4,7,2,3,5) ,year(c.conf_start_time)")
	# 		result = conn.execute(stmt).all()
	# 		results = [dict(r._mapping) for r in result] if result else None
	# 		return results