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 datetime
import numbers
from datetime import datetime
engine = create_engine(app.config['DATABASE_URI_APP'], pool_size=5000,pool_pre_ping=True,pool_recycle=3600)
class BOModel():
def __init__(self):
try:
self.meta = MetaData()
# self.menu_table = Table("menu_table", self.meta, autoload_with=engine)
# self.asset = Table("asset", self.meta, autoload_with=engine)
# self.splash_screen = Table("splash_screen", self.meta, autoload_with=engine)
# self.m_splash_screen = Table("m_splash_screen", self.meta, autoload_with=engine)
# self.pages = Table("pages", self.meta, autoload_with=engine)
# self.page_asset_map = Table("page_asset_map", self.meta, autoload_with=engine)
# self.banner = Table("banner", self.meta, autoload_with=engine)
# self.tab_menu = Table("tab_menu", self.meta, autoload_with=engine)
except Exception as e:
print(e)
# Author : Nallasamy
# Date :25-01-2025
# Version 1
#-- Dashboard--
def get_splash_count(self,app_schema):
with engine.connect() as conn:
stmt = text(f"SELECT count(device_type) as total,count(case when device_type ='android' then 'android' end) as android, count(case when device_type = 'IOS' then 'IOS' end) as IOS FROM {app_schema}.splash_screen;")
result = conn.execute(stmt).all()
conn.close()
return [dict(r._mapping) for r in result] if result else None
# -- Check Schema--
def check_app_schema(self, app_schema):
with engine.connect() as conn:
stmt = text("SELECT COUNT(*) FROM information_schema.schemata WHERE schema_name = :schema_name")
result = conn.execute(stmt, {"schema_name": app_schema}).fetchall()
conn.close()
return [dict(r._mapping) for r in result] if result else None
# -- Conference--
def get_app_conference(self):
with engine.connect() as conn:
stmt = text(f"select * from app_conferences ac inner join app_societies ass on ass.as_id=ac.as_id;")
result =conn.execute(stmt).all()
conn.close()
return [dict(r._mapping) for r in result] if result else None
# --Menu Table--
def get_menu_table(self,app_schema):
with engine.connect() as conn:
stmt = text(f"SELECT *,p.page_name,m.is_visible as menu_visible, case when m.is_visible = 1 then 'active' when m.is_visible = 0 then 'inactive' end as visible_status FROM {app_schema}.menu_table m left join {app_schema}.pages p on p.page_id=m.page_id order by m.id desc;")
result = conn.execute(stmt).all()
conn.close()
return [dict(r._mapping) for r in result] if result else None
def get_menu_count(self,app_schema):
with engine.connect() as conn:
stmt = text(f"SELECT count(is_visible) as total,count(case when is_visible = 1 then 'active' end) as active, count(case when is_visible = 0 then 'inactive' end) as inactive FROM {app_schema}.menu_table;")
result = conn.execute(stmt).all()
conn.close()
return [dict(r._mapping) for r in result] if result else None
def get_app_shema(self,as_id):
with engine.connect() as conn:
stmt = text("select * from app_societies where as_id={};".format(as_id))
result = conn.execute(stmt).first()
conn.close()
if result:
return dict(result._mapping)
else:
return None
def get_asset_table(self,app_schema):
with engine.connect() as conn:
stmt = text(f"select * from {app_schema}.asset;")
result = conn.execute(stmt).all()
conn.close()
return [dict(r._mapping) for r in result] if result else None
def insert_menu_table(self,data,app_schema):
menu_table = Table("menu_table", self.meta, schema=app_schema, autoload_with=engine)
with engine.connect() as conn:
result = conn.execute(menu_table.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 get_menu_title(self,name,app_schema):
with engine.connect() as conn:
stmt = text(f"select * from {app_schema}.menu_table where title in ('{name}') and parent_id=0;")
result = conn.execute(stmt).first()
conn.close()
if result:
return dict(result._mapping)
else:
return None
def get_menu_title_id(self,name,menu_id,app_schema):
with engine.connect() as conn:
stmt = text(f"select * from {app_schema}.menu_table where title = '{name}' and id!='{menu_id}';")
result = conn.execute(stmt).first()
conn.close()
if result:
return dict(result._mapping)
else:
return None
def get_menu_id(self,menu_id,app_schema):
with engine.connect() as conn:
stmt = text(f"select * from {app_schema}.menu_table where id = '{menu_id}';")
result = conn.execute(stmt).first()
conn.close()
if result:
return dict(result._mapping)
else:
return None
def get_asset_id(self,menu_id,app_schema):
with engine.connect() as conn:
stmt = text(f"select * from {app_schema}.asset where asset_id = '{menu_id}';")
result = conn.execute(stmt).first()
conn.close()
if result:
return dict(result._mapping)
else:
return None
def update_menu_data(self,menu_id,data,app_schema):
menu_table = Table("menu_table", self.meta, schema=app_schema, autoload_with=engine)
with engine.connect() as conn:
stmt = menu_table.update().values(data).where(menu_table.c.id.in_([menu_id]))
result = conn.execute(stmt)
conn.commit()
conn.close()
return result
def delete_menu_by_id(self,menu_id,app_schema):
with engine.connect() as conn:
stmt = text(f"delete from {app_schema}.menu_table where id in ({menu_id});")
result = conn.execute(stmt)
conn.commit()
conn.close()
return result
# --Splash Screen--
def get_splash_table(self,app_schema):
with engine.connect() as conn:
stmt = text(f"select * from {app_schema}.splash_screen;")
result = conn.execute(stmt).all()
conn.close()
return [dict(r._mapping) for r in result] if result else None
def delete_splash_by_id(self,userid,app_schema):
with engine.connect() as conn:
stmt = text(f"update {app_schema}.splash_screen set image_data=null where splash_id = '{userid}';")
result = conn.execute(stmt)
conn.commit()
conn.close()
return result
def get_duplicate_splash(self,current_dt,app_schema):
with engine.connect() as conn:
stmt = text(f"insert into {app_schema}.splash_screen (splash_id,image_name,image_width,image_height,device_type,screen_type,screen_size,created_at,updated_at) select m_splash_screen_id,image_name,image_width,image_height,device_type,screen_type,screen_size,'"+str(current_dt)+"','"+str(current_dt)+"' from m_splash_screen ;")
result = conn.execute(stmt)
conn.commit()
conn.close()
return result
def update_splash_data(self,id,data,app_schema):
splash_screen = Table("splash_screen", self.meta, schema=app_schema, autoload_with=engine)
with engine.connect() as conn:
stmt = splash_screen.update().where(splash_screen.c.splash_id.in_([id])).values(data)
result = conn.execute(stmt)
conn.commit()
conn.close()
return result
# -- Banner--
def insert_banner_table(self,data,app_schema):
banner_table = Table("banner", self.meta, schema=app_schema, autoload_with=engine)
with engine.connect() as conn:
result = conn.execute(banner_table.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 update_banner_data(self,ban_id,data,app_schema):
banner_table = Table("banner", self.meta, schema=app_schema, autoload_with=engine)
with engine.connect() as conn:
stmt = banner_table.update().values(data).where(banner_table.c.ban_id.in_([ban_id]))
result = conn.execute(stmt)
conn.commit()
conn.close()
return result
def get_banner_table(self,app_schema):
with engine.connect() as conn:
stmt = text(f"SELECT *,is_visible as banner_visible, case when is_visible = 1 then 'active' when is_visible = 0 then 'inactive' end as visible_status FROM {app_schema}.banner;")
result = conn.execute(stmt).all()
conn.close()
return [dict(r._mapping) for r in result] if result else None
def get_banner_table_id(self,bann_id,app_schema):
with engine.connect() as conn:
stmt = text(f"select * from {app_schema}.banner where ban_id = '{bann_id}';")
result = conn.execute(stmt).first()
conn.close()
if result:
return dict(result._mapping)
else:
return None
def get_banner_count(self,app_schema):
with engine.connect() as conn:
stmt = text(f"SELECT count(is_visible) as total,count(case when is_visible = 1 then 'active' end) as active, count(case when is_visible = 0 then 'inactive' end) as inactive FROM {app_schema}.banner;")
result = conn.execute(stmt).all()
conn.close()
return [dict(r._mapping) for r in result] if result else None
def delete_banner_by_id(self,ban_id,app_schema):
with engine.connect() as conn:
stmt = text(f"delete from {app_schema}.banner where ban_id in ({ban_id});")
result = conn.execute(stmt)
conn.commit()
conn.close()
return result
# --Tab Menu--
def insert_tabmenu_table(self,data,app_schema):
tabmenu_table = Table("tab_menu", self.meta, schema=app_schema, autoload_with=engine)
with engine.connect() as conn:
result = conn.execute(tabmenu_table.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 update_tabmenu_data(self,tab_id,data,app_schema):
tabmenu_table = Table("tab_menu", self.meta, schema=app_schema, autoload_with=engine)
with engine.connect() as conn:
stmt = tabmenu_table.update().values(data).where(tabmenu_table.c.tab_id.in_([tab_id]))
result = conn.execute(stmt)
conn.commit()
conn.close()
return result
def get_tabmenu_table(self,app_schema):
with engine.connect() as conn:
stmt = text(f"SELECT *,is_visible as tab_visible, case when is_visible = 1 then 'active' when is_visible = 0 then 'inactive' end as visible_status FROM {app_schema}.tab_menu;")
result = conn.execute(stmt).all()
conn.close()
return [dict(r._mapping) for r in result] if result else None
def get_tabmenu_count(self,app_schema):
with engine.connect() as conn:
stmt = text(f"SELECT count(is_visible) as total,count(case when is_visible = 1 then 'active' end) as active, count(case when is_visible = 0 then 'inactive' end) as inactive FROM {app_schema}.tab_menu;")
result = conn.execute(stmt).all()
conn.close()
return [dict(r._mapping) for r in result] if result else None
def get_tabmenu_table_id(self,tab_id,app_schema):
with engine.connect() as conn:
stmt = text(f"select * from {app_schema}.tab_menu where tab_id = '{tab_id}';")
result = conn.execute(stmt).first()
conn.close()
if result:
return dict(result._mapping)
else:
return None
def delete_tabmenu_by_id(self,tab_id,app_schema):
with engine.connect() as conn:
stmt = text(f"delete from {app_schema}.tab_menu where tab_id in ({tab_id});")
result = conn.execute(stmt)
conn.commit()
conn.close()
return result
# Author : Vignesh
# Date :25-01-2025
# Version 1
# --Asset Table--
def insert_image(self,data,app_schema):
asset_table = Table("asset", self.meta, schema=app_schema, autoload_with=engine)
with engine.connect() as conn:
result = conn.execute(asset_table.insert(), data)
pk_id = result.inserted_primary_key[0] if result.inserted_primary_key[0] else None
conn.commit()
stmt = text(f"select asset_id,asset_name,is_visible from {app_schema}.asset where asset_id={pk_id} ")
result_1 = conn.execute(stmt).first()
results = dict(result_1._mapping) if result_1 else None
# finalResults = {
# "pk_id":pk_id,
# "asset_data":result2
# }
conn.close()
return results
def checkDuplicate(self,data,f,asset_id,page_id,app_schema):
with engine.connect() as conn:
if f == "UploadImage":
asset_name = data["asset_name"]
stmt = text(f"select COUNT(*) from {app_schema}.asset where asset_name=:asset_name")
stmt = stmt.bindparams(asset_name=f"{asset_name}")
elif f == "updateImage":
asset_name = data["asset_name"]
stmt = text(f"select COUNT(*) from {app_schema}.asset where asset_name=:asset_name and asset_id<>:asset_id")
stmt = stmt.bindparams(asset_name=f"{asset_name}",asset_id=f"{asset_id}")
elif f == "InsertAssetPageData":
asset_id = data["asset_id"]
stmt = text(f"select COUNT(*) from {app_schema}.page_asset_map where asset_id=:asset_id")
stmt = stmt.bindparams(asset_id=f"{asset_id}")
elif f == "UploadPage":
page_name = data["page_name"]
stmt = text(f"select COUNT(*) from {app_schema}.pages where page_name=:page_name")
stmt = stmt.bindparams(page_name=f"{page_name}")
elif f == "updatePage":
page_name = data["page_name"]
stmt = text(f"select COUNT(*) from {app_schema}.pages where page_name=:page_name and page_id<>:page_id")
stmt = stmt.bindparams(page_name=f"{page_name}",page_id=f"{page_id}")
result = conn.execute(stmt).first()
conn.close()
return result
def GetAssetDataById(self,asset_id,app_schema):
with engine.connect() as conn:
stmt = text(f"select * from {app_schema}.asset where asset_id={asset_id} ")
result = conn.execute(stmt).first()
results = dict(result._mapping) if result else None
conn.close()
return results
def delete_asset(self,deleteData,app_schema):
with engine.connect() as conn:
if isinstance(deleteData, numbers.Number):
stmt = text(f"delete from {app_schema}.asset WHERE asset_id = {deleteData}")
elif isinstance(deleteData, list):
if len(deleteData) == 0:
return None
elif len(deleteData) == 1:
stmt = text(f"delete from {app_schema}.asset WHERE asset_id = {deleteData[0]}")
else:
stmt = text(f"delete from {app_schema}.asset WHERE asset_id in {tuple(deleteData)}")
result = conn.execute(stmt)
conn.commit()
conn.close()
return result
def update_asset(self,asset_id,data,app_schema):
asset_table = Table("asset", self.meta, schema=app_schema, autoload_with=engine)
with engine.connect() as conn:
data2 = data
data2.pop("created_at")
stmt1 = asset_table.update().where(asset_table.c.asset_id.in_([asset_id])).values(data2)
result1 = conn.execute(stmt1)
conn.commit()
stmt2 = text(f"select asset_id,asset_name,is_visible from {app_schema}.asset where asset_id={asset_id} ")
result_1 = conn.execute(stmt2).first()
results = dict(result_1._mapping) if result_1 else None
conn.close()
return results
def GetAssetData(self,search_val,app_schema):
with engine.connect() as conn:
if search_val != "":
stmt = text(f"select * from {app_schema}.asset where asset_name like '%{search_val}%'")
else:
stmt = text(f"select * from {app_schema}.asset")
# stmt = text(f"select * from {app_schema}.asset")
result = conn.execute(stmt).all()
results = [dict(r._mapping) for r in result] if result else None
conn.close()
return results
# --Page--
def GetPageData(self,page_id,app_schema):
with engine.connect() as conn:
if page_id is not None:
stmt = text(f"select * from {app_schema}.pages where page_id={page_id}")
result = conn.execute(stmt).first()
results = dict(result._mapping) if result else None
conn.close()
return result
else:
stmt = text(f"select * from {app_schema}.pages")
result = conn.execute(stmt).all()
results = [dict(r._mapping) for r in result] if result else None
conn.close()
return result
def insert_assetPageMap(self,rows,app_schema):
page_asset_map = Table("page_asset_map", self.meta, schema=app_schema, autoload_with=engine)
with engine.connect() as conn:
result = conn.execute(page_asset_map.insert(), rows)
pk_ids = result.inserted_primary_key_rows[0] if result.inserted_primary_key_rows[0] else None
conn.commit()
conn.close()
return result
def GetAssetMapData(self,page_id,app_schema):
with engine.connect() as conn:
stmt = text(f"SELECT mp.pam_id,mp.asset_id,mp.page_id,a.asset_name,a.asset_data,a.asset_type,a.content_type,a.is_visible FROM {app_schema}.page_asset_map mp left join {app_schema}.asset a on mp.asset_id=a.asset_id where page_id={page_id};")
result = conn.execute(stmt).all()
results = [dict(r._mapping) for r in result] if result else None
conn.close()
return results
def DeleteAssetMapData(self,page_asset,app_schema):
with engine.connect() as conn:
res = []
id = ','.join((e) for e in page_asset)
stmt2 = text(f"delete from {app_schema}.page_asset_map WHERE pam_id in ({id})")
result2 = conn.execute(stmt2)
result3 = result2.rowcount
conn.commit()
conn.close()
return res
def insert_page(self,data,app_schema):
pages_table = Table("pages", self.meta, schema=app_schema, autoload_with=engine)
with engine.connect() as conn:
result = conn.execute(pages_table.insert(), data)
pk_id = result.inserted_primary_key[0] if result.inserted_primary_key[0] else None
stmt = text(f"select * from {app_schema}.pages where page_id={pk_id} ")
result_1 = conn.execute(stmt).first()
results = dict(result_1._mapping) if result_1 else None
conn.commit()
conn.close()
return results
def update_page(self,page_id,data,app_schema):
pages_table = Table("pages", self.meta, schema=app_schema, autoload_with=engine)
with engine.connect() as conn:
data2 = data
data2.pop("created_at")
stmt1 = pages_table.update().where(pages_table.c.page_id.in_([page_id])).values(data2)
result1 = conn.execute(stmt1)
stmt2 = text(f"select * from {app_schema}.pages where page_id={page_id} ")
result_1 = conn.execute(stmt2).first()
results = dict(result_1._mapping) if result_1 else None
conn.commit()
conn.close()
return results
def delete_page(self,page_id,app_schema):
with engine.connect() as conn:
stmt = text(f"delete from {app_schema}.pages WHERE page_id = {page_id}")
result = conn.execute(stmt)
conn.commit()
conn.close()
return result
def delete_page_all(self,deleteData,app_schema):
with engine.connect() as conn:
if isinstance(deleteData, numbers.Number):
stmt = text(f"delete from {app_schema}.pages WHERE page_id = {deleteData}")
elif isinstance(deleteData, list):
if len(deleteData) == 0:
return None
elif len(deleteData) == 1:
stmt = text(f"delete from {app_schema}.pages WHERE page_id = {deleteData[0]}")
else:
stmt = text(f"delete from {app_schema}.pages WHERE page_id in {tuple(deleteData)}")
result = conn.execute(stmt)
conn.commit()
conn.close()
return result
def getMenu(self,app_schema):
with engine.connect() as conn:
# results = None
stmt = text(f"SELECT * FROM {app_schema}.menu_table")
result = conn.execute(stmt).all()
conn.close()
return [dict(r._mapping) for r in result] if result else None
def getMenuId(self,page_id,app_schema):
with engine.connect() as conn:
stmt = text(f"SELECT * FROM {app_schema}.menu_table WHERE page_id = {page_id}")
result2 = conn.execute(stmt).all()
results = [dict(r._mapping) for r in result2] if result2 else None
return results
def update_menu(self,menu_id,data,app_schema):
menu_table = Table("menu_table", self.meta, schema=app_schema, autoload_with=engine)
with engine.connect() as conn:
page_id = data["page_id"]
stmt =text(f"update {app_schema}.menu_table SET page_id=0,updated_at='{datetime.now()}' where page_id={page_id}")
resultt = conn.execute(stmt)
stmt1 = menu_table.update().where(menu_table.c.id.in_(menu_id)).values(data)
result = conn.execute(stmt1)
stmt2 = text(f"select * from {app_schema}.menu_table where page_id in ({page_id}) ")
result_1 = conn.execute(stmt2).all()
results = [dict(r._mapping) for r in result_1] if result_1 else None
conn.commit()
conn.close()
return results
def get_count(self,td,app_schema):
with engine.connect() as conn:
stmt = text(f"select count(*) as total_count from {app_schema}.{td};")
result = conn.execute(stmt).first()
results = dict(result._mapping) if result else None
conn.close()
return results
Sindbad File Manager Version 1.0, Coded By Sindbad EG ~ The Terrorists