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
#engine = create_engine(app.config['DATABASE_URI'])
# 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=5000,max_overflow=100,pool_pre_ping=True,pool_recycle=3600)
class MemAppModel():
def __init__(self):
try:
self.meta = MetaData()
self.society_map_member_type = Table("society_map_member_type", self.meta, autoload_with=engine)
self.mail_templates = Table("mail_templates", self.meta, autoload_with=engine)
self.societies = Table("societies", self.meta, autoload_with=engine)
self.society_applications = Table("society_applications", self.meta, autoload_with=engine)
self.society_assets = Table("society_assets", self.meta, autoload_with=engine)
self.m_status = Table("m_status", self.meta, autoload_with=engine)
self.m_steps = Table("m_steps", self.meta, autoload_with=engine)
self.m_attachment_type = Table("m_attachment_type", self.meta,autoload_with=engine)
self.map_membertype_attachment = Table("map_membertype_attachment", self.meta, autoload_with=engine)
self.m_payment_type = Table("m_payment_type", self.meta, autoload_with=engine)
self.ms_setting = Table("ms_setting", self.meta, autoload_with=engine)
self.export_filter_cols = Table("export_filter_cols", self.meta, autoload_with=engine)
self.m_member_type = Table("m_member_type", self.meta, autoload_with=engine)
self.m_work_type = Table("m_work_type", self.meta, autoload_with=engine)
self.countries = Table("countries", self.meta, autoload_with=engine)
self.m_app_type = Table("m_app_type", self.meta, autoload_with=engine)
self.trigger_daily_reports_mails = Table("trigger_daily_reports_mails", self.meta,autoload_with=engine)
except Exception as e:
print(e)
def get_member_applications(self,user_mail):
with engine.connect() as conn:
stmt = text("SELECT sa.*, s.society_name,s.society_title,s.society_logo,s.society_key,s.society_intial,s.e_support_mail,s.e_backup_mails,s.e_secretary_mail_id,case"
+" when is_active = 1 and app_host is not null then 'active'"
+" when is_active = 0 and app_host is null then 'inactive'"
+" when app_host is null then 'incomplete'"
+" end as member_status,u_user_id,u_user_uuid"
+" FROM society_applications sa"
+" left join societies s on s.society_id = sa.society_id"
+" LEFT JOIN ("
+" SELECT u1.*,u2.user_id as u_user_id,u2.user_uuid as u_user_uuid"
+" FROM users u1"
+f" LEFT JOIN (SELECT * FROM users WHERE email = '{user_mail}' GROUP BY society_id ) u2 ON u1.society_id = u2.society_id GROUP BY u1.society_id"
+" ) u ON sa.society_id = u.society_id"
+" where sa.app_type_id=1 order by s.society_id;")
result = conn.execute(stmt).all()
return [dict(r._mapping) for r in result] if result else None
def get_admin_society_map_membertype(self,society_id):
with engine.connect() as conn:
stmt = text("select sm.*,mm.member_type from society_map_member_type sm inner join m_member_type mm where sm.member_type_id=mm.member_type_id and society_id=:society_id;")
result = conn.execute(stmt.bindparams(society_id=society_id)).all()
results = [dict(r._mapping) for r in result] if result else None
if results :
return results
else:
return None
def get_countries(self):
with engine.connect() as conn:
stmt = text("select * from countries;")
results = conn.execute(stmt).all()
results= [dict(r._mapping) for r in results] if results else None
if results :
return results
else:
return None
def get_admin_society_map_membertype_id(self,smmt_id):
with engine.connect() as conn:
stmt = text("select sm.*,mm.member_type from society_map_member_type sm inner join m_member_type mm where sm.member_type_id=mm.member_type_id and smmt_id=:smmt_id ;")
result = conn.execute(stmt.bindparams(smmt_id=smmt_id))
results= result.one_or_none()
if results :
return dict(results._mapping)
else:
return None
def get_abs_typ(self,abs_id,conf_id):
with engine.connect() as conn:
stmt = text("Select concat(abs_type,abs_no) as abs_type from abstracts where conf_id=:conf_id and abs_id=:abs_id;")
result = conn.execute(stmt.bindparams(abs_id=abs_id,conf_id=conf_id))
results= result.one_or_none()
if results :
return dict(results._mapping)
else:
return None
def update_admin_society_map_membertype(self,smmt_id,data):
with engine.connect() as conn:
stmt = self.society_map_member_type.update().where(self.society_map_member_type.c.smmt_id.in_([smmt_id])).values(data)
result = conn.execute(stmt)
conn.commit()
return result
def check_member_type(self,member_type_id,society_id):
with engine.connect() as conn:
stmt = self.society_map_member_type.select().where(self.society_map_member_type.c.member_type_id.in_([member_type_id])).where(self.society_map_member_type.c.society_id.in_([society_id]))
result = conn.execute(stmt)
results = result.one_or_none()
if results :
return results._mapping
else :
return None
def insert_admin_society_map_membertype(self,data):
with engine.connect() as conn:
result = conn.execute(self.society_map_member_type.insert(), data)
conn.commit()
pk_id = result.inserted_primary_key[0] if result.inserted_primary_key[0] else None
return pk_id
#Mail template function
def insert_admin_mail_template(self,data):
with engine.connect() as conn:
result = conn.execute(self.mail_templates.insert(), data)
conn.commit()
pk_id = result.inserted_primary_key[0] if result.inserted_primary_key[0] else None
return pk_id
def update_admin_mail_template(self,mail_template_id,data):
with engine.connect() as conn:
stmt = self.mail_templates.update().where(self.mail_templates.c.mail_template_id.in_([mail_template_id])).values(data)
result = conn.execute(stmt)
conn.commit()
return result
def check__admin_mail_template(self,template_name,society_id):
with engine.connect() as conn:
stmt = self.mail_templates.select().where(self.mail_templates.c.template_name.in_([template_name])).where(self.mail_templates.c.society_id.in_([society_id]))
result = conn.execute(stmt)
results = result.one_or_none()
if results :
return dict(results._mapping)
else :
return None
def get_admin_mail_template(self,society_id,mail_template_id):
with engine.connect() as conn:
stmt = text("select * from mail_templates where society_id=:society_id and mail_template_id=:mail_template_id and app_type_id=1;")
results = conn.execute(stmt.bindparams(society_id=society_id,mail_template_id=mail_template_id))
results= results.one_or_none()
if results :
return results._mapping
else:
return None
def get_admin_mail_template_name(self,society_id):
with engine.connect() as conn:
stmt = text("select * from mail_templates where society_id=:society_id and app_type_id =1;")
results = conn.execute(stmt.bindparams(society_id=society_id)).all()
results= [dict(r._mapping) for r in results] if results else None
if results :
return results
else:
return None
def insert_mail_template_bulk(self,society_id,def_society_id):
with engine.connect() as conn:
stmt_1=text(f"insert into mail_templates (app_type_id,society_id,is_layout,is_active,template_name,subject_type,subject,mail_type,mail_content,is_send_backup) select app_type_id,{society_id},is_layout,is_active,template_name,subject_type,subject,mail_type,mail_content,is_send_backup from mail_templates where society_id={def_society_id};")
result = conn.execute(stmt_1)
conn.commit()
return "success"
def get_mail_template_preview(self,society_id,mail_template_id):
with engine.connect() as conn:
stmt = text("select * from mail_templates where society_id=:society_id and mail_template_id=:mail_template_id and app_type_id =1;")
results = conn.execute(stmt.bindparams(society_id=society_id,mail_template_id=mail_template_id))
results= results.one_or_none()
if results :
return dict(results._mapping)
else:
return None
def get_societies(self):
with engine.connect() as conn:
stmt = text("select * from societies;")
results = conn.execute(stmt).all()
results= [dict(r._mapping) for r in results] if results else None
if results :
return results
else:
return None
def Get_Conf(self):
with engine.connect() as conn:
stmt = text("select * from societies s inner join conference c on c.society_id=s.society_id order by s.society_id,c.conf_start_time desc;")
results = conn.execute(stmt).all()
results= [dict(r._mapping) for r in results] if results else None
if results :
return results
else:
return None
def get_society_app(self,society_id):
with engine.connect() as conn:
# stmt = text("select * from society_applications where app_type_id=1 and society_id=:society_id;")
stmt = text("select * from society_applications where society_id=:society_id;")
results = conn.execute(stmt.bindparams(society_id=society_id)).all()
results= [dict(r._mapping) for r in results] if results else None
if results :
return results
else:
return None
def get_societies_byid(self,society_id):
with engine.connect() as conn:
stmt = text("select * from societies where society_id=:society_id ;")
results = conn.execute(stmt.bindparams(society_id=society_id))
results= results.one_or_none()
if results :
return dict(results._mapping)
else:
return None
def check_society_by_key(self,society_key):
with engine.connect() as conn:
stmt = text("select * FROM societies where society_key='"+str(society_key)+"';")
result = conn.execute(stmt)
results = result.one_or_none()
if results :
return results._mapping
else :
return None
def check_society_by_key_id(self,society_key,society_id):
with engine.connect() as conn:
stmt = text("select * FROM societies where society_key='"+str(society_key)+"' and society_id !="+str(society_id)+";")
result = conn.execute(stmt)
results = result.one_or_none()
if results :
return results._mapping
else :
return None
def check_society_by_intial(self,society_intial):
with engine.connect() as conn:
stmt = text("select * FROM societies where society_intial='"+str(society_intial)+"';")
result = conn.execute(stmt)
results = result.one_or_none()
if results :
return results._mapping
else :
return None
def check_society_by_intial_id(self,society_intial,society_id):
with engine.connect() as conn:
stmt = text("select * FROM societies where society_intial='"+str(society_intial)+"' and society_id !="+str(society_id)+";")
result = conn.execute(stmt)
results = result.one_or_none()
if results :
return results._mapping
else :
return None
def check_society_by_name(self,society_name):
with engine.connect() as conn:
stmt = text("select * FROM societies where society_name='"+str(society_name)+"';")
result = conn.execute(stmt)
results = result.one_or_none()
if results :
return results._mapping
else :
return None
def check_society_by_name_id(self,society_name,society_id):
with engine.connect() as conn:
stmt = text("select * FROM societies where society_name='"+str(society_name)+"' and society_id !="+str(society_id)+";")
result = conn.execute(stmt)
results = result.one_or_none()
if results :
return results._mapping
else :
return None
def update_socities(self,society_id,data):
with engine.connect() as conn:
stmt = self.societies.update().where(self.societies.c.society_id.in_([society_id])).values(data)
result = conn.execute(stmt)
conn.commit()
return result
def insert_socities(self,data):
with engine.connect() as conn:
result = conn.execute(self.societies.insert(), data)
conn.commit()
pk_id = result.inserted_primary_key[0] if result.inserted_primary_key[0] else None
return pk_id
def get_society_applications(self):
with engine.connect() as conn:
stmt = text("select * from society_applications where app_type_id=1;")
results = conn.execute(stmt).all()
results= [dict(r._mapping) for r in results] if results else None
if results :
return results
else:
return None
def get_society_applications_byid(self,society_id):
with engine.connect() as conn:
stmt = text("select * from society_applications where app_type_id=1 and society_id=:society_id;")
results = conn.execute(stmt.bindparams(society_id=society_id))
results= results.one_or_none()
if results :
return dict(results._mapping)
else:
return None
def update_society_applications(self,app_id,data):
with engine.connect() as conn:
stmt = self.society_applications.update().where(self.society_applications.c.app_id.in_([app_id])).values(data)
result = conn.execute(stmt)
conn.commit()
return result
def insert_society_applications(self,data):
with engine.connect() as conn:
result = conn.execute(self.society_applications.insert(), data)
conn.commit()
pk_id = result.inserted_primary_key[0] if result.inserted_primary_key[0] else None
return pk_id
def insert_m_status_bulk(self,society_id,memapro_society_id):
with engine.connect() as conn:
stmt = text("insert into m_status( status_id, status, display_name, order_no, society_id, description, is_disable, created_at, updated_at, deleted_at, current_status, status_for_mail)"
+"select status_id, status, display_name, order_no, "+str(society_id)+", description, is_disable, created_at, updated_at, deleted_at, current_status, status_for_mail from m_status_template where society_id=:memapro_society_id;")
result = conn.execute(stmt.bindparams(memapro_society_id=memapro_society_id))
conn.commit()
return result
def delet_m_status(self,society_id):
with engine.connect() as conn:
stmt=text("delete from m_status where society_id=:society_id")
result = conn.execute(stmt.bindparams(society_id=society_id))
conn.commit()
return result
def get_admin_society_assets(self,society_id):
with engine.connect() as conn:
stmt = text("select * from society_assets where society_id=:society_id;")
results = conn.execute(stmt.bindparams(society_id=society_id)).all()
results= [dict(r._mapping) for r in results] if results else None
if results :
return results
else:
return None
def get_asset_name(self):
with engine.connect() as conn:
stmt = text("select distinct asset_name from society_assets;")
results = conn.execute(stmt).all()
results= [dict(r._mapping) for r in results] if results else None
if results :
return results
else:
return None
def get_asset_by_id(self,society_id):
with engine.connect() as conn:
stmt = text("select distinct asset_name from society_assets where society_id=:society_id;")
results = conn.execute(stmt.bindparams(society_id=society_id)).all()
results= [dict(r._mapping) for r in results] if results else None
if results :
return results
else:
return None
def get_society_id_duplicate(self,society_key):
with engine.connect() as conn:
stmt = text("select * from societies where society_key=:society_key;")
results = conn.execute(stmt.bindparams(society_key=society_key))
results= results.one_or_none()
if results :
return dict(results._mapping)
else:
return None
def get_admin_society_assets_byids(self,society_asset_id):
with engine.connect() as conn:
stmt = text("select * from society_assets where society_asset_id=:society_asset_id ;")
results = conn.execute(stmt.bindparams(society_asset_id=society_asset_id))
results= results.one_or_none()
if results :
return dict(results._mapping)
else:
return None
def update_admin_society_assets(self,data):
with engine.connect() as conn:
if data :
for row in data :
society_asset_id = row['society_asset_id']
stmt = self.society_assets.update().where(self.society_assets.c.society_asset_id.in_([society_asset_id])).values(row)
result = conn.execute(stmt)
conn.commit()
return result
def check_asset_name(self,asset_name,society_id):
with engine.connect() as conn:
stmt = self.society_assets.select().where(self.society_assets.c.asset_name.in_([asset_name])).where(self.society_assets.c.society_id.in_([society_id]))
result = conn.execute(stmt)
results = result.one_or_none()
if results :
return results._mapping
else :
return None
def insert_society_assets_bulk(self,stmt):
with engine.connect() as conn:
stmt_1=text(""+str(stmt)+"")
result = conn.execute(stmt_1)
conn.commit()
return "success"
def insert_society_assets(self,data):
with engine.connect() as conn:
result = conn.execute(self.society_assets.insert(), data)
conn.commit()
pk_id = result.inserted_primary_key[0] if result.inserted_primary_key[0] else None
return pk_id
def get_m_status(self,society_id):
with engine.connect() as conn:
stmt = text("select * from m_status where society_id=:society_id ;")
results = conn.execute(stmt.bindparams(society_id=society_id)).all()
results= [dict(r._mapping) for r in results] if results else None
if results :
return results
else:
return None
def get_m_status_byids(self,m_status_id):
with engine.connect() as conn:
stmt = text("select * from m_status where m_status_id=:m_status_id ;")
results = conn.execute(stmt.bindparams(m_status_id=m_status_id))
results= results.one_or_none()
if results :
return dict(results._mapping)
else:
return None
def update_m_status(self,m_status_id,data):
with engine.connect() as conn:
stmt = self.m_status.update().where(self.m_status.c.m_status_id.in_([m_status_id])).values(data)
result = conn.execute(stmt)
conn.commit()
return result
def insert_m_status(self,data):
with engine.connect() as conn:
result = conn.execute(self.m_status.insert(), data)
conn.commit()
pk_id = result.inserted_primary_key[0] if result.inserted_primary_key[0] else None
return pk_id
def get_m_all_steps(self):
with engine.connect() as conn:
stmt = text("select distinct step_name,page_name, get_function_name, post_function_name FROM m_steps ;")
results = conn.execute(stmt).all()
results= [dict(r._mapping) for r in results] if results else None
if results :
return results
else:
return None
def get_previous_step(self,society_id):
with engine.connect() as conn:
stmt = text("select ifnull(MAX(step_no+1),1) as order_by from m_steps where society_id =:society_id;")
results = conn.execute(stmt.bindparams(society_id=society_id))
results= results.one_or_none()
if results :
return dict(results._mapping)
else:
return None
def check_step_name(self,step_name,society_id):
with engine.connect() as conn:
stmt = self.m_steps.select().where(self.m_steps.c.step_name.in_([step_name])).where(self.m_steps.c.society_id.in_([society_id]))
result = conn.execute(stmt)
results = result.one_or_none()
if results :
return results._mapping
else :
return None
def get_m_steps(self,society_id):
with engine.connect() as conn:
stmt = text("select * from m_steps where society_id=:society_id;")
results = conn.execute(stmt.bindparams(society_id=society_id)).all()
results= [dict(r._mapping) for r in results] if results else None
if results :
return results
else:
return None
def get_m_steps_byids(self,m_steps_id):
with engine.connect() as conn:
stmt = text("select * from m_steps where m_steps_id=:m_steps_id ;")
results = conn.execute(stmt.bindparams(m_steps_id=m_steps_id))
results= results.one_or_none()
if results :
return dict(results._mapping)
else:
return None
def insert_m_steps(self,data):
with engine.connect() as conn:
result = conn.execute(self.m_steps.insert(), data)
conn.commit()
pk_id = result.inserted_primary_key[0] if result.inserted_primary_key[0] else None
return pk_id
def update_m_steps(self,m_steps_id,data):
with engine.connect() as conn:
stmt = self.m_steps.update().where(self.m_steps.c.m_steps_id.in_([m_steps_id])).values(data)
result = conn.execute(stmt)
conn.commit()
return result
def get_m_attachment_type(self,society_id):
with engine.connect() as conn:
stmt = text("select * from m_attachment_type where society_id=:society_id;")
results = conn.execute(stmt.bindparams(society_id=society_id)).all()
results= [dict(r._mapping) for r in results] if results else None
if results :
return results
else:
return None
def get_m_attachment_type_byids(self,attach_type_id):
with engine.connect() as conn:
stmt = text("select * from m_attachment_type where attach_type_id=:attach_type_id ;")
results = conn.execute(stmt.bindparams(attach_type_id=attach_type_id))
results= results.one_or_none()
if results :
return dict(results._mapping)
else:
return None
def update_m_attachment_type(self,attach_type_id,data):
with engine.connect() as conn:
stmt = self.m_attachment_type.update().where(self.m_attachment_type.c.attach_type_id.in_([attach_type_id])).values(data)
result = conn.execute(stmt)
conn.commit()
return result
def insert_m_attachment_type(self,data):
with engine.connect() as conn:
result = conn.execute(self.m_attachment_type.insert(), data)
conn.commit()
pk_id = result.inserted_primary_key[0] if result.inserted_primary_key[0] else None
return pk_id
def get_map_membertype_attachment(self,society_id,attach_type_id):
with engine.connect() as conn:
stmt = text("select * from map_membertype_attachment mp inner join m_attachment_type m inner join m_member_type mm on mp.attach_type_id= m.attach_type_id and mp.member_type_id=mm.member_type_id where society_id=:society_id and m.attach_type_id=:attach_type_id ;")
# SELECT mm.member_type, m.attach_type,mp.* FROM map_membertype_attachment mp inner join m_attachment_type m inner join m_member_type mm on m.attach_type_id= mp.attach_type_id and mp.member_type_id=mm.member_type_id where society_id=1;
results = conn.execute(stmt.bindparams(society_id=society_id,attach_type_id=attach_type_id)).all()
conn.commit()
results= [dict(r._mapping) for r in results] if results else None
if results :
return results
else:
return None
def not_map_membertype(self,society_id,attach_type_id):
with engine.connect() as conn:
stmt = text("select mm.* from society_map_member_type sm inner join m_member_type mm on sm.member_type_id = mm.member_type_id where society_id =:society_id and sm.member_type_id not in (select member_type_id from map_membertype_attachment where attach_type_id =:attach_type_id);")
results = conn.execute(stmt.bindparams(society_id=society_id,attach_type_id=attach_type_id)).all()
conn.commit()
results= [dict(r._mapping) for r in results] if results else None
if results :
return results
else:
return None
def get_map_member_type_attachment_byids(self,map_ma_id):
with engine.connect() as conn:
stmt = text("select * from map_membertype_attachment mp inner join m_attachment_type m inner join m_member_type mm on mp.attach_type_id= m.attach_type_id and mp.member_type_id=mm.member_type_id where map_ma_id=:map_ma_id ;")
results = conn.execute(stmt.bindparams(map_ma_id=map_ma_id))
results= results.one_or_none()
if results :
return dict(results._mapping)
else:
return None
def update_map_membertype_attachment(self,map_ma_id,data):
with engine.connect() as conn:
stmt = self.map_membertype_attachment.update().where(self.map_membertype_attachment.c.map_ma_id.in_([map_ma_id])).values(data)
result = conn.execute(stmt)
conn.commit()
return result
def check_attach_type(self,attach_type,society_id):
with engine.connect() as conn:
stmt = self.m_attachment_type.select().where(self.m_attachment_type.c.attach_type.in_([attach_type])).where(self.m_attachment_type.c.society_id.in_([society_id]))
result = conn.execute(stmt)
results = result.one_or_none()
if results :
return dict(results._mapping)
else :
return None
def get_all_attachtype(self):
with engine.connect() as conn:
stmt = text("select * FROM m_attachment_type group by attach_type,attach_extension,label_name;")
results = conn.execute(stmt).all()
results= [dict(r._mapping) for r in results] if results else None
if results :
return results
else:
return None
def get_attach_type(self,attach_type,society_id):
with engine.connect() as conn:
stmt = text("select * FROM numerote_primary_db.m_attachment_type where attach_type=:attach_type and society_id=:society_id;")
results = conn.execute(stmt.bindparams(attach_type=attach_type,society_id=society_id))
results= results.one_or_none()
if results :
return dict(results._mapping)
else:
return None
def get_order_no(self,society_id):
with engine.connect() as conn:
stmt = text("select ifnull(MAX(order_no+1),1) as order_no from m_attachment_type where society_id =:society_id;")
results = conn.execute(stmt.bindparams(society_id=society_id))
results= results.one_or_none()
if results :
return dict(results._mapping)
else:
return None
def check_member_type_id(self,attach_type_id):
with engine.connect() as conn:
# stmt = self.map_membertype_attachment.select().where(self.map_membertype_attachment.c.member_type_id.in_([member_type_id])).where(self.map_membertype_attachment.c.attach_type_id.in_([attach_type_id]))
# stmt = text("select * FROM map_membertype_attachment where attach_type_id=:attach_type_id and member_type_id not in ("+str(member_type_id)+") ;")
stmt=text("select * FROM map_membertype_attachment where attach_type_id=:attach_type_id")
result = conn.execute(stmt.bindparams(attach_type_id=attach_type_id))
results = result.all()
results= [dict(r._mapping) for r in results] if results else None
if results :
return results
else:
return None
def insert_map_membertype_attachment(self,data):
with engine.connect() as conn:
result = conn.execute(self.map_membertype_attachment.insert(), data)
conn.commit()
pk_id = result.inserted_primary_key[0] if result.inserted_primary_key[0] else None
return pk_id
def get_m_payment_type(self,society_id):
with engine.connect() as conn:
stmt = text("select * from m_payment_type where is_membership=1 and society_id=:society_id;")
results = conn.execute(stmt.bindparams(society_id=society_id)).all()
results= [dict(r._mapping) for r in results] if results else None
if results :
return results
else:
return None
def get_all_payment(self):
with engine.connect() as conn:
stmt = text("select distinct payment_type from m_payment_type where is_membership=1;")
results = conn.execute(stmt).all()
results= [dict(r._mapping) for r in results] if results else None
if results :
return results
else:
return None
def check_payment_type(self,payment_type,society_id):
with engine.connect() as conn:
# stmt = self.m_payment_type.select().where(self.m_payment_type.c.payment_type.in_([payment_type])),self.m_payment_type.c.society_id.in_([society_id])
stmt =text("select * from m_payment_type where payment_type =:payment_type and society_id = :society_id and is_membership = 1;")
result = conn.execute(stmt.bindparams(payment_type=payment_type,society_id = society_id))
results = result.one_or_none()
return dict(results._mapping) if results else None
def get_payment(self,payment_type):
with engine.connect() as conn:
stmt = text("select description,payment_content from m_payment_type where is_membership=1 and payment_type=:payment_type")
results = conn.execute(stmt.bindparams(payment_type=payment_type)).all()
results= [dict(r._mapping) for r in results] if results else None
if results :
return results
else:
return None
def get_m_payment_type_byids(self,m_payment_id):
with engine.connect() as conn:
stmt = text("select * from m_payment_type where m_payment_id=:m_payment_id ;")
results = conn.execute(stmt.bindparams(m_payment_id=m_payment_id))
results= results.one_or_none()
if results :
return dict(results._mapping)
else:
return None
def update_m_payment_type(self,m_payment_id,data):
with engine.connect() as conn:
stmt = self.m_payment_type.update().where(self.m_payment_type.c.m_payment_id.in_([m_payment_id])).values(data)
result = conn.execute(stmt)
conn.commit()
return result
def insert_m_payment_type(self,data):
with engine.connect() as conn:
result = conn.execute(self.m_payment_type.insert(), data)
conn.commit()
pk_id = result.inserted_primary_key[0] if result.inserted_primary_key[0] else None
return pk_id
def get_ms_setting(self):
with engine.connect() as conn:
stmt = text("select * from ms_setting;")
results = conn.execute(stmt).all()
results= [dict(r._mapping) for r in results] if results else None
if results :
return results
else:
return None
def get_ms_setting_byids(self,society_id):
with engine.connect() as conn:
stmt = text("select * from ms_setting where society_id=:society_id ;")
results = conn.execute(stmt.bindparams(society_id=society_id))
results= results.one_or_none()
if results :
return dict(results._mapping)
else:
return None
def update_ms_setting(self,ms_setting_id,data):
with engine.connect() as conn:
stmt = self.ms_setting.update().where(self.ms_setting.c.ms_setting_id.in_([ms_setting_id])).values(data)
result = conn.execute(stmt)
conn.commit()
return result
def insert_ms_setting(self,data):
with engine.connect() as conn:
result = conn.execute(self.ms_setting.insert(), data)
conn.commit()
pk_id = result.inserted_primary_key[0] if result.inserted_primary_key[0] else None
return pk_id
def get_export_filter_cols(self,society_id):
with engine.connect() as conn:
stmt = text("select * from export_filter_cols where is_mem=1 and find_in_set("+str(society_id)+",society_ids);")
results = conn.execute(stmt).all()
results= [dict(r._mapping) for r in results] if results else None
if results :
return results
else:
return None
def get_cols_name(self):
with engine.connect() as conn:
stmt = text("select distinct cols_display_name,cols_value_name,society_ids from export_filter_cols where is_mem=1;")
results = conn.execute(stmt).all()
results= [dict(r._mapping) for r in results] if results else None
if results :
return results
else:
return None
def get_export_filter_cols_byids(self,cols_id):
with engine.connect() as conn:
stmt = text("select * from export_filter_cols where cols_id=:cols_id ;")
results = conn.execute(stmt.bindparams(cols_id=cols_id))
results= results.one_or_none()
if results :
return dict(results._mapping)
else:
return None
def update_export_filter_cols(self,cols_id,data):
with engine.connect() as conn:
stmt = self.export_filter_cols.update().where(self.export_filter_cols.c.cols_id.in_([cols_id])).values(data)
result = conn.execute(stmt)
conn.commit()
return result
def insert_export_filter_cols(self,data):
with engine.connect() as conn:
result = conn.execute(self.export_filter_cols.insert(), data)
conn.commit()
pk_id = result.inserted_primary_key[0] if result.inserted_primary_key[0] else None
return pk_id
def get_member_type(self):
with engine.connect() as conn:
stmt = text("select * from m_member_type")
results = conn.execute(stmt).all()
results= [dict(r._mapping) for r in results] if results else None
if results :
return results
else:
return None
def get_member_type_society(self,society_id):
with engine.connect() as conn:
stmt = text("select * FROM society_map_member_type sm inner join m_member_type mm where society_id=:society_id and sm.member_type_id=mm.member_type_id;")
results = conn.execute(stmt.bindparams(society_id=society_id)).all()
results= [dict(r._mapping) for r in results] if results else None
if results :
return results
else:
return None
def get_member_type_byids(self,member_type_id):
with engine.connect() as conn:
stmt = text("select * from m_member_type where member_type_id=:member_type_id ;")
results = conn.execute(stmt.bindparams(member_type_id=member_type_id))
results= results.one_or_none()
if results :
return dict(results._mapping)
else:
return None
def get_member_id(self,member_type):
with engine.connect() as conn:
stmt = text("select * from m_member_type where member_type=:member_type;")
results = conn.execute(stmt.bindparams(member_type=member_type))
results= results.one_or_none()
if results :
return dict(results._mapping)
else:
return None
def update_member_type(self,member_type_id,data):
with engine.connect() as conn:
stmt = self.m_member_type.update().where(self.m_member_type.c.member_type_id.in_([member_type_id])).values(data)
result = conn.execute(stmt)
conn.commit()
return result
def insert_member_type(self,data):
with engine.connect() as conn:
result = conn.execute(self.m_member_type.insert(), data)
conn.commit()
pk_id = result.inserted_primary_key[0] if result.inserted_primary_key[0] else None
return pk_id
def get_m_work_type(self,society_id):
with engine.connect() as conn:
stmt = text("select * from m_work_type where society_id=:society_id;")
results = conn.execute(stmt.bindparams(society_id=society_id)).all()
results= [dict(r._mapping) for r in results] if results else None
if results :
return results
else:
return None
def get_m_work_type_byids(self,work_type_id):
with engine.connect() as conn:
stmt = text("select * from m_work_type where work_type_id=:work_type_id ;")
results = conn.execute(stmt.bindparams(work_type_id=work_type_id))
results= results.one_or_none()
if results :
return dict(results._mapping)
else:
return None
def update_work_type(self,work_type_id,data):
with engine.connect() as conn:
stmt = self.m_work_type.update().where(self.m_work_type.c.work_type_id.in_([work_type_id])).values(data)
result = conn.execute(stmt)
conn.commit()
return result
def insert_work_type(self,data):
with engine.connect() as conn:
result = conn.execute(self.m_work_type.insert(), data)
conn.commit()
pk_id = result.inserted_primary_key[0] if result.inserted_primary_key[0] else None
return pk_id
def get_all_m_work_type(self):
with engine.connect() as conn:
stmt = text("select distinct work_type from m_work_type;")
results = conn.execute(stmt).all()
results= [dict(r._mapping) for r in results] if results else None
if results :
return results
else:
return None
def check_work_type(self,work_type,society_id):
with engine.connect() as conn:
stmt = self.m_work_type.select().where(self.m_work_type.c.work_type.in_([work_type])).where(self.m_work_type.c.society_id.in_([society_id]))
result = conn.execute(stmt)
results = result.one_or_none()
if results :
return results._mapping
else :
return None
def get_order_by(self):
with engine.connect() as conn:
stmt = text("select max(orderby+1) as order_no from export_filter_cols where is_mem=1;")
result = conn.execute(stmt)
results = result.one_or_none()
if results :
return results._mapping
else :
return None
def check_export_filter_cols(self,cols_display_name,society_id):
with engine.connect() as conn:
stmt = text("select * from export_filter_cols where cols_display_name=:cols_display_name and is_mem=1 and find_in_set("+str(society_id)+",society_ids);")
result = conn.execute(stmt.bindparams(cols_display_name=cols_display_name))
results = result.one_or_none()
if results :
return results._mapping
else :
return None
def update_society_ids(self,society_id,cols_display_name):
with engine.connect() as conn:
stmt = text("update export_filter_cols set society_ids=Concat(society_ids , ',"+str(society_id)+"') where is_mem=1 and cols_display_name in ('"+str(cols_display_name)+"') ;")
conn.execute(stmt)
conn.commit()
stmt_1 = text("select * from export_filter_cols where cols_display_name=:cols_display_name and is_mem=1 and find_in_set("+str(society_id)+",society_ids);")
result = conn.execute(stmt_1.bindparams(cols_display_name=cols_display_name))
results = result.one_or_none()
if results :
return results._mapping
else :
return None
def get_daily_report(self,society_id):
with engine.connect() as conn:
stmt = text("select * from trigger_daily_reports_mails where society_id=:society_id and is_mem=1;")
results = conn.execute(stmt.bindparams(society_id=society_id)).all()
results= [dict(r._mapping) for r in results] if results else None
if results :
return results
else:
return None
def get_daily_report_by_ids(self,report_id):
with engine.connect() as conn:
stmt = text("select * from trigger_daily_reports_mails where report_id=:report_id ;")
results = conn.execute(stmt.bindparams(report_id=report_id))
results= results.one_or_none()
if results :
return dict(results._mapping)
else:
return None
def update_daily_report(self,report_id,data):
with engine.connect() as conn:
stmt = self.trigger_daily_reports_mails.update().where(self.trigger_daily_reports_mails.c.report_id.in_([report_id])).values(data)
result = conn.execute(stmt)
conn.commit()
return result
# def insert_daily_report(self,data):
# with engine.connect() as conn:
# result = conn.execute(self.trigger_daily_reports_mails.insert(), data)
# conn.commit()
# pk_id = result.inserted_primary_key[0] if result.inserted_primary_key[0] else None
# return pk_id
def check_email_id(self,email,society_id):
with engine.connect() as conn:
stmt = self.trigger_daily_reports_mails.select().where(self.trigger_daily_reports_mails.c.email.in_([email])).where(self.trigger_daily_reports_mails.c.society_id.in_([society_id]))
result = conn.execute(stmt)
results = result.one_or_none()
if results :
return results._mapping
else :
return None
def insert_daily_report(self,data):
with engine.connect() as conn:
result = conn.execute(self.trigger_daily_reports_mails.insert(), data)
conn.commit()
pk_id = result.inserted_primary_key[0] if result.inserted_primary_key[0] else None
return pk_id
# vimal
def GetM_App_Data(self):
with engine.connect() as conn:
stmt=text("select * from m_app_type;")
result=conn.execute(stmt).all()
results=[dict(r._mapping) for r in result] if result else None
if results:
return results
else:
return None
def GetConf(self,society_id):
with engine.connect() as conn:
stmt=text("select * from conference where society_id="+str(society_id)+";")
result=conn.execute(stmt).all()
results=[dict(r._mapping) for r in result] if result else None
if results:
return results
else:
return None
def get_profile_application_by_app_id(self,app_type_id,society_id):
with engine.connect() as conn:
stmt = text(f"select * from society_applications where society_id={society_id} and app_type_id={app_type_id};")
result = conn.execute(stmt).first()
return dict(result._mapping) if result else None
def get_membership_status_count(self):
with engine.connect() as conn:
stmt = text("select count(*) as membership_app,"
+" sum(case when is_active = 1 and app_host is not null then 1 else 0 end) as active_count,"
+" sum(case when is_active = 0 and app_host is null then 1 else 0 end) as inactive_count,"
+" sum(case when is_active is null and app_host is null then 1 else 0 end) as incomplete"
+" from society_applications"
+" where app_type_id=1;")
result = conn.execute(stmt).first()
return dict(result._mapping) if result else None
def check_admin_email(self,email):
with engine.connect() as conn:
stmt = text("select * FROM admin_access where admin_email=:email and admin_role_id=2")
results = conn.execute(stmt.bindparams(email=email))
results= results.one_or_none()
if results :
return dict(results._mapping)
else:
return None
Sindbad File Manager Version 1.0, Coded By Sindbad EG ~ The Terrorists