Sindbad~EG File Manager

from sqlalchemy import create_engine, MetaData, Table, insert, select,update,delete,text
from sqlalchemy.sql import and_, or_
from .. import Cryptography,Auth
from core import app
import json
import datetime
from datetime import timedelta,date,datetime
from .. import engine
from sqlalchemy.exc import SQLAlchemyError
from sqlalchemy.dialects.mysql import insert


class APIImportModel():
    def __init__(self):
        try:
            self.meta = MetaData()
            # self.abstracts = Table("abstracts", self.meta, autoload_with=engine)
            # self.author    = Table("abs_topics", self.meta, autoload_with=engine)
            # self.marks     = Table("abs_marks", self.meta, autoload_with=engine)
            # self.abs_uploads   = Table("abs_uploads", self.meta, autoload_with=engine)
        except Exception as e:
            print(e)


    def ImpFPDataSave(self,tmp_imp_apao_fp):
        try:
            if tmp_imp_apao_fp:
                with engine.connect() as conn:
                    # data_list   = session['students']
                    dynamic_table = Table('tmp_imp_apao_fp', self.meta, autoload_with=engine)
                    stmt        = insert(dynamic_table).values(tmp_imp_apao_fp)
                    print("stmt -- ",stmt)
                    update_dict = {key: stmt.inserted[key] for key in tmp_imp_apao_fp[0] if key != 'abstractId'}
        
                    stmt = stmt.on_duplicate_key_update(**update_dict)
                    
                    conn.execute(stmt)
                    
                    conn.commit()
                    conn.close()
            return 'success'

        except SQLAlchemyError as e:
            print(f'Error inserting data: {str(e)}')
            return f'Error inserting data: {str(e)}'


    def ImpFPJudgeData(self,tmp_imp_apao_fp_judge):
        try:
            if tmp_imp_apao_fp_judge:
                with engine.connect() as conn:
                    # data_list   = session['students']
                    dynamic_table = Table('tmp_imp_apao_fp_judge', self.meta, autoload_with=engine)
                    stmt        = insert(dynamic_table).values(tmp_imp_apao_fp_judge)
                    print("stmt -- ",stmt)
                    update_dict = {key: stmt.inserted[key] for key in tmp_imp_apao_fp_judge[0] if key != 'id'}
        
                    stmt = stmt.on_duplicate_key_update(**update_dict)
                    
                    conn.execute(stmt)
                    
                    conn.commit()
                    conn.close()
            return 'success'

        except SQLAlchemyError as e:
            print(f'Error inserting data: {str(e)}')
            return f'Error inserting data: {str(e)}'



    def ImpICDataSave(self,imp_tmp_apao_ic):
        try:
            if imp_tmp_apao_ic:
                with engine.connect() as conn:
                    # data_list   = session['students']
                    dynamic_table = Table('imp_tmp_apao_ic', self.meta, autoload_with=engine)
                    stmt        = insert(dynamic_table).values(imp_tmp_apao_ic)
                    print("stmt -- ",stmt)
                    update_dict = {key: stmt.inserted[key] for key in imp_tmp_apao_ic[0] if key != 'code'}
        
                    stmt = stmt.on_duplicate_key_update(**update_dict)
                    
                    conn.execute(stmt)
                    
                    conn.commit()
                    conn.close()
            return 'success'

        except SQLAlchemyError as e:
            print(f'Error inserting data: {str(e)}')
            return f'Error inserting data: {str(e)}'

    def ImpGPDataSave(self,tmp_imp_apao_gp_data):
        try:
            if tmp_imp_apao_gp_data:
                with engine.connect() as conn:
                    # data_list   = session['students']
                    dynamic_table = Table('tmp_imp_apao_gp_data', self.meta, autoload_with=engine)
                    stmt        = insert(dynamic_table).values(tmp_imp_apao_gp_data)
                    print("stmt -- ",stmt)
                    update_dict = {key: stmt.inserted[key] for key in tmp_imp_apao_gp_data[0] if key != 'sess_code'}
        
                    stmt = stmt.on_duplicate_key_update(**update_dict)
                    
                    conn.execute(stmt)
                    
                    conn.commit()
                    conn.close()
            return 'success'

        except SQLAlchemyError as e:
            print(f'Error inserting data: {str(e)}')
            return f'Error inserting data: {str(e)}'

    def ImpGPUserDataSave(self,tmp_imp_apao_gp_user_data):
        try:
            if tmp_imp_apao_gp_user_data:
                with engine.connect() as conn:
                    # data_list   = session['students']
                    dynamic_table = Table('tmp_imp_apao_gp_user_data', self.meta, autoload_with=engine)
                    stmt        = insert(dynamic_table).values(tmp_imp_apao_gp_user_data)
                    print("stmt -- ",stmt)
                    update_dict = {key: stmt.inserted[key] for key in tmp_imp_apao_gp_user_data[0] if key != 'abstractId'}
        
                    stmt = stmt.on_duplicate_key_update(**update_dict)
                    
                    conn.execute(stmt)
                    
                    conn.commit()
                    conn.close()
            return 'success'

        except SQLAlchemyError as e:
            print(f'Error inserting data: {str(e)}')
            return f'Error inserting data: {str(e)}'


    def ImpICCOADataSave(self,tmp_imp_apao_ic_coi):
        try:
            if tmp_imp_apao_ic_coi:
                with engine.connect() as conn:
                    # data_list   = session['students']
                    dynamic_table = Table('tmp_imp_apao_ic_coi', self.meta, autoload_with=engine)
                    stmt        = insert(dynamic_table).values(tmp_imp_apao_ic_coi)
                    print("stmt -- ",stmt)
                    update_dict = {key: stmt.inserted[key] for key in tmp_imp_apao_ic_coi[0] if key != 'abstractId'}
        
                    stmt = stmt.on_duplicate_key_update(**update_dict)
                    
                    conn.execute(stmt)
                    
                    conn.commit()
                    conn.close()
            return 'success'

        except SQLAlchemyError as e:
            print(f'Error inserting data: {str(e)}')
            return f'Error inserting data: {str(e)}'


    def GetICData(self):
        with engine.connect() as conn:
            stmt=text('select * from imp_tmp_apao_ic')
            result = conn.execute(stmt).all()
            results = [dict(r._mapping) for r in result] if result else None
            conn.close()
            return results

    def GetGPData(self):
        with engine.connect() as conn:
            stmt=text('select * from tmp_imp_apao_gp_data')
            result = conn.execute(stmt).all()
            results = [dict(r._mapping) for r in result] if result else None
            conn.close()
            return results

    def GetGPUsersData(self):
        with engine.connect() as conn:
            stmt=text('select * from tmp_imp_apao_gp_user_data')
            result = conn.execute(stmt).all()
            results = [dict(r._mapping) for r in result] if result else None
            conn.close()
            return results


    def GetFPData(self):
        with engine.connect() as conn:
            stmt=text('select * from tmp_imp_apao_fp order by sess_date,s_time,abs_order asc ')
            result = conn.execute(stmt).all()
            results = [dict(r._mapping) for r in result] if result else None
            conn.close()
            return results

    def GetFPJudgeData(self):
        with engine.connect() as conn:
            stmt=text('select * from tmp_imp_apao_fp_judge')
            result = conn.execute(stmt).all()
            results = [dict(r._mapping) for r in result] if result else None
            conn.close()
            return results

    def GetICCOAData(self):
        with engine.connect() as conn:
            stmt=text('select * from tmp_imp_apao_ic_coi')
            result = conn.execute(stmt).all()
            results = [dict(r._mapping) for r in result] if result else None
            conn.close()
            return results


    def UpdateICCAStatusData(self,code):
        with engine.connect() as conn:
            stmt=text('update imp_tmp_apao_ic set status_id=4 where code in ('+str(code)+');')
            # print(stmt)
            result = conn.execute(stmt)
            conn.commit()
            conn.close()
            return result

    def UpdateGpStatusData(self,code):
        with engine.connect() as conn:
            stmt=text('update tmp_imp_apao_gp_data set status_id=4 where sess_code in ('+str(code)+');')
            # print(stmt)
            result = conn.execute(stmt)
            conn.commit()
            conn.close()
            return result

    def UpdateGpUserStatusData(self,code):
        with engine.connect() as conn:
            stmt=text('update tmp_imp_apao_gp_user_data set status_id=4 where abstractId in ('+str(code)+');')
            # print(stmt)
            result = conn.execute(stmt)
            conn.commit()
            conn.close()
            return result

    def UpdateICCOAStatusData(self,code):
        with engine.connect() as conn:
            stmt=text('update tmp_imp_apao_ic_coi set status_id=4 where code in ('+str(code)+');')
            # print(stmt)
            result = conn.execute(stmt)
            conn.commit()
            conn.close()
            return result


    def UpdateFPStatusData(self,code):
        with engine.connect() as conn:
            stmt=text('update tmp_imp_apao_fp set status_id=4 where abstractId in ('+str(code)+');')
            print(stmt)
            result = conn.execute(stmt)
            conn.commit()
            conn.close()
            return result


    def UpdateFPJudgeStatusData(self,code):
        with engine.connect() as conn:
            stmt=text('update tmp_imp_apao_fp_judge set status_id=4 where id in ('+str(code)+');')
            print(stmt)
            result = conn.execute(stmt)
            conn.commit()
            conn.close()
            return result

    def GetAPAOGpData(self):
        with engine.connect() as conn:
            stmt=text("SELECT gpu.name,gpu.role,gpu.sess_code,gpu.topic,gp.sess_name,gpu.status_id,gp.s_time,"
                    +" gp.e_time,gp.sess_date,gp.hall FROM tmp_imp_apao_gp_data gp "
                    +" left join tmp_imp_apao_gp_user_data gpu on gp.sess_code=gpu.sess_code "
                    +" order by gp.sess_date,gp.s_time,gpu.role asc;")
            result = conn.execute(stmt).all()
            results = [dict(r._mapping) for r in result] if result else None
            conn.close()
            return results

    def GetAPAOICData(self):
        with engine.connect() as conn:
            stmt=text("select * from  imp_tmp_apao_ic ca"
            +" left join tmp_imp_apao_ic_coi coa on ca.code=coa.code"
            +" order by ca.sess_date,ca.s_time;")
            result = conn.execute(stmt).all()
            results = [dict(r._mapping) for r in result] if result else None
            conn.close()
            return results

    # def GetFPData(self):
    #     with engine.connect() as conn:
    #         stmt=text('select * from tmp_imp_apao_fp;')
    #         result=conn.execute(stmt).all()
    #         results=[dict(r._mapping) for r in result] if result else None
    #         conn.close()
    #         return results

    def GetFPJudgeData(self):
        with engine.connect() as conn:
            stmt=text('select * from tmp_imp_apao_fp_judge;')
            result=conn.execute(stmt).all()
            results=[dict(r._mapping) for r in result] if result else None
            conn.close()
            return results