Sindbad~EG File Manager

from locale import currency
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'], poolclass=None,pool_size=5000,max_overflow=100,pool_pre_ping=True,pool_recycle=3600)


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

	def updatePayment(self,unique_id,data):
		with engine.connect() as conn:
			if unique_id and "null" not in unique_id :
				stmt     = self.user_payment.update().where(self.user_payment.c.unique_id.in_([unique_id])).values(data)
				result   = conn.execute(stmt)
				conn.commit()

				stmt_1   = text("select * from user_payment up inner join users u on up.user_id = u.user_id where unique_id=:unique_id;")
				result_1 = conn.execute(stmt_1.bindparams(unique_id=unique_id)).first()
				if result_1:
					return dict(result_1._mapping)
				else:
					return None	
			else :
				return "Unique id missing"   

	def insert_bopaymentdata(self,data):
		with engine.connect() as conn:
			result = conn.execute(self.user_payment.insert(), data)
			conn.commit()
			# return result.lastrowid
			pk_id = result.inserted_primary_key[0] if result.inserted_primary_key[0] else None
			return pk_id  
	
	# def insertPaymentData(self,user_id,society_id,am_id,unique_id,is_test,dt_string,payment_for,remarks,app_type):
	# 	stmt  	 = text("select m.amount,m.currency from users u inner join society_map_member_type m on  m.member_type_id = u.choosed_member_type_id  and (FIND_IN_SET(u.country_id,  m.country_ids) or  m.country_ids is null) where u.user_id =:user_id and m.society_id=:society_id;")
	# 	conn 	 = engine.connect()
	# 	results  = conn.execute(stmt,user_id=user_id,society_id=society_id)
	# 	result	 = results.fetchone()
	# 	amount	 = result.amount
	# 	currency = result.currency
	# 	data 	 = {'user_id' : user_id,'amount' : amount,'unique_id' :unique_id,'am_id':am_id,'is_test':is_test,'created_at' :dt_string,'payment_for':payment_for,'currency':currency,'remarks':remarks,'society_id':society_id,'app_type':app_type}
	# 	result_1 = conn.execute(self.user_payment.insert(), data)
	# 	conn.close()
	# 	return "success"

	def insertPaymentData(self,user_id,society_id,am_id,unique_id,is_test,dt_string,payment_for,remarks,app_type):
		connection = engine.raw_connection()
		cursor      = connection.cursor()
		cursor.callproc("usp_get_paymentData",[user_id,society_id])
		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()
		if results :
			result = results[0]
		else:
			return None  
		amount	 = result['amount']
		currency = result['currency']
		with engine.connect() as conn:
			data 	 = {'user_id' : user_id,'amount' : amount,'unique_id' :unique_id,'status':"IN PROGRESS",'am_id':am_id,'is_test':is_test,'created_at' :dt_string,'payment_for':payment_for,'currency':currency,'remarks':remarks,'society_id':society_id,'app_type':app_type}
			result_1 = conn.execute(self.user_payment.insert(), data)
			conn.commit()
			return "success"   

	def insert_payment(self,data):
		with engine.connect() as conn:
			result = conn.execute(self.user_payment.insert(), data)
			conn.commit()
			pk_id = result.inserted_primary_key[0] if result.inserted_primary_key[0] else None
			return pk_id

	def update_payments_data(self,payment_id,user_id,data):
		with engine.connect() as conn:   
			stmt_1   = self.user_payment.update().where(self.user_payment.c.payment_id.in_([payment_id])).where(self.user_payment.c.user_id.in_([user_id])).values(data)
			result_1 = conn.execute(stmt_1)
			conn.commit()

			stmt_2   = text("select * from user_payment where user_id=:user_id and payment_id=:payment_id;")
			result_2 = conn.execute(stmt_2.bindparams(user_id=user_id,payment_id=payment_id)).first()
			if result_2:
				return result_2._mapping
			else:
				return None	

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

	def get_payment_unique(self,society_id,unique_id):
		with engine.connect() as conn:
			stmt   = text("SELECT u.prefix,u.full_name,u.member_type_id,up.user_id,up.payment_id,up.created_at,up.utr_number,up.payment_method,u.approved_member_type_id,up.status,u.status_id,u.membership_no from users u inner join user_payment up on  up.user_id = u.user_id where up.society_id=:society_id and up.unique_id=:unique_id;")
			result = conn.execute(stmt.bindparams(society_id=society_id,unique_id=unique_id))
			output = result.first()
			if output:
				return dict(output._mapping)
			else:
				return None		

	def get_already_payment(self,user_id,app_type):
		with engine.connect() as conn:
			stmt   = text("SELECT * from user_payment where user_id=:user_id and app_type=:app_type limit 1 ;")
			result = conn.execute(stmt.bindparams(user_id=user_id,app_type=app_type))
			output = result.first()
			if output:
				return dict(output._mapping)
			else:
				return None	

	def get_payment_datas(self,user_id,app_type):
		with engine.connect() as conn:
			stmt   = text("SELECT * from user_payment where user_id=:user_id and status=:status and app_type=:app_type ;")
			result = conn.execute(stmt.bindparams(user_id=user_id,status="success",app_type=app_type))
			output = result.first()
			if output:
				return dict(output._mapping)
			else:
				return None	

	def get_unique_id(self,society_id,app_type,cur_date):
		with engine.connect() as conn:
			stmt = text("select * from user_payment where society_id=:society_id and app_type=:app_type  and (status is null or status !='success') and date(created_at)=:cur_date;")
			results = conn.execute(stmt.bindparams(society_id=society_id,app_type=app_type,cur_date=cur_date)).all()
			return [dict(r._mapping) for r in results] if results else None
			
	def get_previou_payment(self,user_id,app_type,cur_date_time,cur_date_time_plus):
		with engine.connect() as conn:
			stmt   = text("SELECT * from user_payment where user_id=:user_id and app_type=:app_type and created_at between '"+str(cur_date_time_plus)+"' and '"+str(cur_date_time)+"' ;")
			results = conn.execute(stmt.bindparams(user_id=user_id,app_type=app_type)).all()
			return [dict(r._mapping) for r in results] if results else None
			
	def get_payment_verification_data(self,society_id,app_type):
		with engine.connect() as conn:
			# stmt = text("select up.*,u.f,u.status_id from user_payment up inner join users u on up.user_id=u.user_id where up.society_id=:society_id and up.app_type=:app_type  and up.created_at between cur_date_time and cur_date_time_plus;")
			stmt=text("select up.*,u.status_id,u.prefix,u.full_name,u.email,u.mobile from user_payment up inner join users u on up.user_id=u.user_id where up.society_id="+str(society_id)+" and up.app_type=app_type and up.status='IN PROGRESS'order by payment_id desc;")
			results = conn.execute(stmt).all()
			return [dict(r._mapping) for r in results] if results else None
			
	def get_payment(self,payment_id):
		with engine.connect() as conn:
			stmt = text("select * from user_payment where payment_id=:payment_id;")
			results = conn.execute(stmt.bindparams(payment_id=payment_id))
			output = results.first()
			if output:
				return dict(output._mapping)
			else:
				return None