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
from .. import engine

#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=20, max_overflow=0)
# engine = create_engine(app.config['DATABASE_URI'],pool_size=5000,max_overflow=100,pool_pre_ping=True,pool_recycle=3600)
# engine = create_engine(app.config['DATABASE_URI'], poolclass=None,pool_size=5000,max_overflow=100,pool_pre_ping=True,pool_recycle=3600)

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

	def usp_get_reference_details(self,user_id,reference_by,type):
		connection  = engine.raw_connection()
		cursor      = connection.cursor()
		cursor.callproc("usp_get_reference_details",[user_id,reference_by,type])
		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()
			connection.close()
			if results :
				return results
			else :
				return None 
		else : 
			cursor.close()
			connection.commit()
			connection.close()
			return None
	
	def usp_get_reference(self,user_id,reference_by):
		connection  = engine.raw_connection()
		cursor      = connection.cursor()
		cursor.callproc("usp_get_reference",[user_id,reference_by])
		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()
			connection.close()
			if results :
				return results
			else :
				return None 
		else :
			cursor.close()
			connection.commit()
			connection.close() 
			return None

	def usp_get_reference_v1(self,user_uuid,reference_user_uuid):
		connection  = engine.raw_connection()
		cursor      = connection.cursor()
		cursor.callproc("usp_get_reference_v1",[user_uuid,reference_user_uuid])
		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()
			connection.close()
			if results :
				return results
			else :
				return None 
		else :
			cursor.close()
			connection.commit()
			connection.close() 
			return None
			
	def insert_prosec(self,data):
		with engine.connect() as conn:
			result = conn.execute(self.reference.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_prosec(self,user_id,type,data):
		with engine.connect() as conn:
			stmt = self.reference.update().where(self.reference.c.user_id.in_([user_id])).where(self.reference.c.type.in_([type])).values(data)
			result = conn.execute(stmt)
			conn.commit()
			conn.close() 
			if result:
				return 'success'
			else :
				return 'fail'
	

	def delete_prosec(self,reference_id):
		with engine.connect() as conn:
			stmt = text("delete from reference WHERE reference_id IN("+str(reference_id)+")")
			result = conn.execute(stmt)
			conn.commit()
			conn.close()
			return result
	
	def count_pro_sec(self,user_id):
		with engine.connect() as conn:
			stmt = text("SELECT COUNT(user_id) as user_id FROM reference where user_id="+ str(user_id)  +";")
			result = conn.execute(stmt).first()
			conn.close()
			if result :
				return dict(result._mapping)
			else:
				return None
	
	# def check_prosec(self,user_id):
	#     with engine.connect() as conn:
	#     stmt = text("select reference_by,type from reference where user_id   = "+str(user_id)+";")
	#     result = conn.execute(stmt)
	#     results = [dict(r) for r in result] if result else None
	#     conn.close()
	#     if results :
	#         return results[0]
	#     else:
	#         return None
	
	def get_reference(self,user_id,reference_by):
		with engine.connect() as conn:
			stmt = text("select * from reference where user_id= "+str(user_id)+ " and reference_by="+str(reference_by)+ ";")
			result = conn.execute(stmt).first()
			conn.close()
			if result:
				return dict(result._mapping)
			else:
				return None	

	# def get_reference_by(self,user_id):
	#     with engine.connect() as conn:
	#     stmt = text("select reference_by from reference where user_id= "+str(user_id)+ ";")
	#     results = conn.execute(stmt)
	#     output = results.fetchall()
	#     conn.close()
	#     return output
	
	# def check_accept_reject(self,user_id,reference_by):
	#     with engine.connect() as conn:
	#     stmt = text("select COUNT(approved_on) as Accepted,COUNT(rejected_on) as Rejected from reference where user_id="+str(user_id)+ " and reference_by="+str(reference_by)+";")
	#     result = conn.execute(stmt)
	#     results = [dict(r) for r in result] if result else None
	#     conn.close()
	#     if results :
	#         return results[0]
	#     else:
	#         return None

	def check_accept_both(self,user_id):
		with engine.connect() as conn:
			stmt = text("select COUNT(approved_on) as Accepted from reference where user_id=:user_id;")
			result = conn.execute(stmt.bindparams(user_id=user_id))
			output = result.first()
			conn.close()
			return output
	
	def update_prosec_acc_rej(self,user_id,reference_by,data_1):
		with engine.connect() as conn:
			stmt = self.reference.update().where(self.reference.c.user_id.in_([user_id])).where(self.reference.c.reference_by.in_([reference_by])).values(data_1)
			result = conn.execute(stmt)
			conn.commit() 
			conn.close()
			if result:
				return 'success'
			else :
				return 'fail'

	def update_reminder_prosec(self,user_id,referenceData):
		with engine.connect() as conn:
			stmt = self.reference.update().where(self.reference.c.user_id.in_([user_id])).values(referenceData)
			result = conn.execute(stmt)
			conn.commit() 
			conn.close()
			if result:
				return 'success'
			else :
				return 'fail'
				
	def get_all_prosec_by_reference(self,user_id,society_id):
		sets = []
		try:
			connection = engine.raw_connection()
			cursor = connection.cursor()
			cursor.callproc("usp_get_prosec_per_user",[user_id,society_id])
			while 1:
				#(column_name, type_, ignore_, ignore_, ignore_, null_ok, column_flags)
				names = [c[0] for c in cursor.description]
				set_ = []
				while 1:
					row_raw = cursor.fetchone()
					if row_raw is None:
						break
						
					row = dict(zip(names, row_raw))
					set_.append(row)
	 
				sets.append(list(set_))
	 
				if cursor.nextset() is None:
					break
	 
				# nextset() doesn't seem to be sufficiant to tell the end.
				if cursor.description is None:
					break
		finally:
			# Return the connection to the pool (won't actually close).
			connection.close()
			
		return sets