dbilayer_postgre_SQL

core/constants.py

@@ -0,0 +1,46 @@
+columns_users_table="dbuserstype,dbuserid,dbusersname,dbusersemail,dbusersdp,dbusersrole,dbusernameid,dbpasswordid,status"
+column_dbtype_table="dbtypename,dbtypeid,dbtypedesc,dbschemaid,dbcategoryid,dbinstanceid,dbnameid,status"
+columns_dbacl_table = "dbaclname,dbuserid,dbaclid,status"
+column_dbauth_table = "dbauthdesc,dbauthid,status"
+column_dbbilling_table = "dbbillingname,dbbillingid,dbcustomerid,amount,dbbillingdate,dbbillinglastupdate,dbinvoiceid,status"
+column_dbcategory_table = "dbcategoryname,dbcategoryid,dbschemaid,dbcategorydesc,status"
+column_dbcharges_table = "dbchargename,dbchargeid,dbschemaid,status"
+column_dbcity_table = "dbcityname,dbcityid,dbstateid,status"
+column_dbconnectionstring_table = "dbconnectionstringname,dbconnectionstringid,dbusernameid,dbpasswordid,dbipaddressid,dbtypeid,status"
+column_dbcollection_table = "dbcollectionname,dbcollectionid,status"
+column_dbcountry_table = "dbcountryname,dbcountryid,dbcountrydesc,status"
+column_dbcustomer_table = "dbfirstname,dbcustomerid,dblastname,dbemailid,dbuserid,dbaddress,dbcreatedate,dblastupdated,dbplanid,status"
+column_dbdeleteNote_table = "dbdeletenotename,dbdeletenoteid,dbdeletenotedesc,status"
+column_dbdeploy_table = "dbdeployname,dbdeployid,dbbillingid,status"
+column_dbemail_table = "dbemail,dbemailid,status"
+column_dbencoding_table = "dbencodingdesc,dbencodingid,dbencodingname,status"
+column_dbGenInvoice_table = "dbgeninvoiceid,dbgeninvoicetype,dbinvoiceid,status"
+column_dbgst_table = "dbgstnumber,dbgstid,status"
+column_dbhash_table = "dbhashname,dbhashid,dbhashtype,status"
+column_dbinstance_table = "dbinstancename,dbinstanceid,dbportid,dbipaddressid,dbusernameid,dbpasswordid,dbschemaid,status"
+column_dbinvoice_table = "dbinvoicenumber,dbinvoiceid,dbinvoiceperiodstartdate,dbinvoicelineitemid,dbcustomerid,dbinvoicedate,dbinvoiceperiodenddate,dbchargeid,status"
+column_dbinvoicelineitem_table = "dbinvoicelineitemname,dbinvoicelineitemid,status"
+column_dbipaddress_table = "dbipaddressvalue,dbipaddressid,dbipaddressdesc,dbusernameid,dbpasswordid,status"
+column_dbkyc_table = "dbkycdesc,dbkycid,dbtypeid,status"
+column_dbname_table = "dbname,dbnameid,dbschemaid,dbcategoryid,status"
+column_dborders_table = "dborderid,dbordername,dbbillingid,dbpackageid,status"
+column_dborganization_table = "dborganizationname,dborganizationid,dborganizationdesc,dbpanid,status"
+column_dbpackage_table = "dbpackagename,dbpackageid,status"
+column_dbpan_table = "dbpannumber,dbpanid,dbemailid,dbphoneid,dbkycid,status"
+column_dbpassword_table = "dbpassword,dbpasswordid,dbpassworddesc,dbusernameid,dbcategoryid,status"
+column_dbpermission_table = "dbpermissionname,dbpermissionid,dbtypeid,dbaclid,status"
+column_dbphone_table = "dbphonenumber,dbphoneid,status"
+column_dbpincode_table = "dbpincode,dbpincodeid,dbcityid,dbstateid,dbcountryid,status"
+column_dbplan_table = "dbplanname,dbplanid,status"
+column_dbplanbilling_table = "dbplanbillingname,dbplanbillingid,dbpackageid,dbplanid,status"
+column_dbplans_table = "dbplansid,dbplansname,dbtypeid,dbbillingid,status"
+column_dbpo_table = "dbponumber,dbpoid,dbinvoiceid,dbbillingid,dbcustomerid,dborganizationid,status"
+column_dbportnumber_table = "dbportnumbername,dbportid,dbportnumbercategory,dbportnumberdesc,dbcountryid,dbpincodeid,dbusernameid,dbpasswordid,status"
+column_dbprod_table = "dbprodname,dbprodid,status"
+column_dbrole_table = "dbrolename,dbroleid,dbuserid,dbroledesc,dbpermissionid,status"
+column_dbschema_table = "dbschemaname,dbschemaid,dbschemadesc,dbcollectionid,dbauthid,dbencodingid,dbvariabletypeid,status"
+column_dbstate_table = "dbstatename,dbstateid,dbcountryid,dbstatedesc,status"
+column_dbuac_table = "dbuactype,dbuacid,dbroleid,dbuacname,status"
+column_username_table = "dbusername,dbusernameid,dbusernamedesc,dbnameid,dbcategoryid,status"
+column_dbusagelimit_table = "dbusagelimitmin,dbusagelimitid,dbschemaid,dborganizationid,dbroleid,dbplanid,dbusagelimitmax,status"
+column_dbvariabletype_table="dbvariabletypename,dbvariabletypeid,status"

core/dbil/dbilayer.py

@@ -0,0 +1,847 @@
+
+# import mysql.connector
+import re
+from werkzeug.security import generate_password_hash
+import json
+import psycopg2
+import sys
+# Set up the connection string
+#connection_string = 'DRIVER={ODBC Driver 17 for SQL Server};SERVER=localhost;DATABASE=dbilayer;UID=sa;PWD=Ganesh@m0477;'
+# Connect to the database
+#db_connection = pyodbc.connect(connection_string)
+
+# db_connection = mysql.connector.connect(
+#         host="localhost",
+#         user="root",
+#         passwd="Machint@123",
+#         database="dbiLayer"
+#     )
+
+# db_connection = mysql.connector.connect(
+#         host="10.11.0.24",
+#         user="root",
+#         passwd="Machint@2022",
+#         database="reactpropmod",
+#         port=3303
+#     )
+'''
+db_connection = mariadb.connect(
+        user="root",
+        password="123456",
+        host="127.0.0.1",
+        port=3306,
+        database="dbilayer"
+
+    )
+'''
+db_connection = psycopg2.connect(
+    host="localhost",
+    database="dbilayer",
+    user='postgres',
+    password='123456',
+    port= '5432'
+)
+# Registration for user
+'''
+def registerUserNow(tablename, fields, userData):
+    my_database=db_connection.cursor()
+    username=userData['username']
+    useremail=userData['useremail']
+    userpassword=userData['userpassword']
+    userdesig=userData['userdesig']
+    status=userData['status']
+    try:
+        query_for_user_existence="SELECT * FROM {} WHERE username='{}'".format(tablename, username)
+        if not re.fullmatch(r'[^@]+@[^@]+\.[^@]+', useremail):
+            msg='Invalid Email Address !'
+        elif not re.fullmatch(r'[A-Za-z0-9]+', username):
+            msg='Username must contain only characters and numbers !'
+        elif (not username) or (not userpassword) or (not useremail):
+            msg='Please provide the complete details !'
+        elif username:
+            try:
+                my_database.execute(query_for_user_existence)
+                user_exist=my_database.fetchone()
+                if user_exist:
+                    msg='User already exists!'
+                else:
+                    hashed_password=generate_password_hash(userpassword)
+                    sql_query="INSERT INTO {}({}) VALUES('{}', '{}','{}','{}','{}')".format(tablename, fields,username,useremail,hashed_password,userdesig,status)
+                    try:
+                        my_database.execute(sql_query)
+                        db_connection.commit()
+                        msg='User Register/Created Successfully !'
+                    except:
+                        msg='User Creation Failed'
+            except:
+                msg='Failed'
+    except:
+        msg='Failed'
+    # db_connection.close()
+    return msg
+
+# Login User
+
+def getUserActivity(tablename, fields, userData):
+    my_database=db_connection.cursor(dictionary=True)
+    sql_query="SELECT {} FROM {} WHERE username='{}'".format(fields, tablename, userData['username'])
+    try:
+        my_database.execute(sql_query)
+        output=my_database.fetchone()
+    except:
+        output={"Error":"No data recieved or error occured"}
+    # db_connection.close()
+    print(output)
+    return output
+
+'''
+
+ 
+
+def readallWithoutCondition(tablename, fields,column_index_of):
+    my_database = db_connection.cursor()
+    sql_query = "SELECT {} FROM {}".format(fields,tablename)
+    print(sql_query)
+    try:
+        my_database.execute(sql_query)
+        rows = my_database.fetchall()
+        print(rows)
+        dictionary=[]
+        for each in rows:
+            eachdict={}
+            indexof=0
+            for e in each:
+                eachdict[column_index_of[indexof]]=e
+                indexof+=1
+            dictionary.append(eachdict)
+        retval = "Success"
+        return dictionary
+    except Exception as err:
+        print("database error: ---->", err)
+        retval = "Failure"  
+        return retval 
+
+def readallWithCondition(tablename, fields, condition,column_index_of):
+    my_database = db_connection.cursor()
+    sql_query = "SELECT {} FROM {} WHERE {}".format(fields,tablename,condition)
+    print(sql_query)
+    try:
+        my_database.execute(sql_query)
+        rows = my_database.fetchall()
+        dictionary=[]
+        for each in rows:
+            eachdict={}
+            indexof=0
+            for e in each:
+                eachdict[column_index_of[indexof]]=e
+                indexof+=1
+            dictionary.append(eachdict)
+        retval = "Success"
+        return dictionary
+    except :
+        retval = "Failure"  
+        return retval     
+    
+def readOneWithcondition(tablename, fields, cond,column_index_of):
+    my_database = db_connection.cursor()
+    sql_query = "SELECT {} FROM {} WHERE {}".format(fields,tablename,cond)
+    print(sql_query)
+    # try:
+    my_database.execute(sql_query)
+    rows = my_database.fetchall()
+    dictionary=[]
+    for each in rows:
+        eachdict={}
+        indexof=0
+        for e in each:
+            eachdict[column_index_of[indexof]]=e
+            indexof+=1
+        dictionary.append(eachdict)
+    retval = "Success"
+    return dictionary
+    # except :
+    #     retval = "Failure"  
+    #     return retval 
+    
+def insertIntoDBWithoutCondition(tablename,fields,data):
+    my_database=db_connection.cursor()
+    sql_query="INSERT INTO {} ({}) VALUES({})".format(tablename, fields, data)
+    print(sql_query)
+    try:
+        my_database.execute(sql_query)
+        db_connection.commit()
+        retval = "Success"
+        return retval
+    except Exception as err:
+        print("database error: ---->", err)
+        retval = "Failure"
+        return retval     
+    
+def updateValuesIndb(tablename,updatestatement,condition):
+    my_database = db_connection.cursor()
+    sql_statement = "UPDATE "  + tablename + " SET " + updatestatement + " WHERE " + condition + ""
+    print(sql_statement)
+    try:
+        my_database.execute(sql_statement)
+        db_connection.commit()
+        retval = "Success"
+        return retval
+    except:
+        retval = "Failure"  
+        return retval 
+    
+def updateDataWithCondition(tablename,updateStatement,condition):
+    pass
+
+    
+
+
+
+    
+  
+
+
+    
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+'''
+def registerUserNow(tablename, fields, userData):
+    my_database=db_connection.cursor()
+    username=userData['username']
+    useremail=userData['useremail']
+    userpassword=userData['userpassword']
+    userdesig=userData['userdesig']
+    status=userData['status']
+    try:
+        query_for_user_existence="SELECT * FROM {} WHERE username='{}'".format(tablename, username)
+        if not re.fullmatch(r'[^@]+@[^@]+\.[^@]+', useremail):
+            msg='Invalid Email Address !'
+        elif not re.fullmatch(r'[A-Za-z0-9]+', username):
+            msg='Username must contain only characters and numbers !'
+        elif (not username) or (not userpassword) or (not useremail):
+            msg='Please provide the complete details !'
+        elif username:
+            try:
+                my_database.execute(query_for_user_existence)
+                user_exist=my_database.fetchone()
+                if user_exist:
+                    msg='User already exists!'
+                else:
+                    hashed_password=generate_password_hash(userpassword)
+                    sql_query="INSERT INTO {}({}) VALUES('{}', '{}','{}','{}','{}')".format(tablename, fields,username,useremail,hashed_password,userdesig,status)
+                    try:
+                        my_database.execute(sql_query)
+                        db_connection.commit()
+                        msg='User Register/Created Successfully !'
+                    except:
+                        msg='User Creation Failed'
+            except:
+                msg='Failed'
+    except:
+        msg='Failed'
+    # db_connection.close()
+    return msg
+
+# Login User
+
+def getUserActivity(tablename, fields, userData):
+    my_database=db_connection.cursor(dictionary=True)
+    sql_query="SELECT {} FROM {} WHERE username='{}'".format(fields, tablename, userData['username'])
+    try:
+        my_database.execute(sql_query)
+        output=my_database.fetchone()
+    except:
+        output={"Error":"No data recieved or error occured"}
+    # db_connection.close()
+    print(output)
+    return output
+
+# Return List of Available stored single column values for any table
+
+def returnspecificlist(field, tablename):
+    my_database=db_connection.cursor(dictionary=True)
+    sql_query="SELECT {} FROM {}".format(field, tablename)
+    try:
+        my_database.execute(sql_query)
+        stored_column_data=my_database.fetchall()
+        final_stored_column_data_list=[]
+        for name_dict in stored_column_data:
+            final_stored_column_data_list.append(name_dict[field])
+    except:
+        final_stored_column_data_list=[]
+    return final_stored_column_data_list
+
+#Inseret Values into any table except propset
+
+def insertintotablewocond(tablename, fields, data, namefield):
+    final_stored_names_list=returnspecificlist(namefield, tablename)
+    print(final_stored_names_list)
+    my_database=db_connection.cursor()
+    sql_query="INSERT INTO {}({}) VALUES({})".format(tablename, fields, data)
+    print(sql_query)
+    print(final_stored_names_list)
+    sql_statement = "SELECT "  + fields + " from " + tablename  + " GROUP BY" + fields
+    print(sql_statement)
+    try:
+        my_database.execute(sql_query)
+        db_connection.commit()
+
+        my_database.execute("SELECT LAST_INSERT_ID()")   
+        last_inserted_id=my_database.fetchone()  
+        last_inserted_id=last_inserted_id[0]
+
+        retVal={"message": "Success", "last_insert_id": last_inserted_id, "stored_names": final_stored_names_list}
+    except:
+        retVal={"message": "Failed", "last_insert_id": None}
+    return retVal
+
+
+#Read one with condition from any table
+
+def readoneonewithcond(tablename, fields, condition):
+    my_database=db_connection.cursor(dictionary=True)
+    condition_data=''
+    for key, value in condition.items():
+        if isinstance(value, str):
+            condition_data += " {}='{}' AND".format(key, value)
+        else:
+            condition_data += " {}={} AND".format(key, value)
+    len_of_condition=len(condition_data)
+    condition_data=condition_data[:(len_of_condition-3)]
+    sql_query="SELECT {} FROM {} WHERE {}".format(fields, tablename, condition_data)
+    try:
+        my_database.execute(sql_query)
+        output=my_database.fetchall()
+        """ if (len(output) == 1):
+            output=output[0]
+        else:
+            output=output """
+    except:
+        output = {"Error":"No Data Recieved or Error Occured"}
+    return output
+
+#Read many with condition from any table
+
+def readmanywithcond(tablename, fields, condition):
+    my_database=db_connection.cursor(dictionary=True)
+    condition_data=''
+    request_condition=''
+    for key,value in condition.items():
+        if isinstance(value, str):
+            condition_data += "{}={}".format(key, value)
+            request_condition=value
+    if request_condition == 'all':
+        sql_query="SELECT {} FROM {} WHERE status='1'".format(fields, tablename)
+    else:
+        sql_query="SELECT {} FROM {} WHERE status='1' AND {}".format(fields, tablename, condition_data)
+    print(sql_query)
+    try:
+        my_database.execute(sql_query)
+        output=my_database.fetchall()
+    except:
+        output = {"Error":"No Data Recieved or Error Occured"}
+    return output
+
+#Read Many without condition(status) from any table
+
+def readmanywocond(tablename, fields, condition):
+    my_database=db_connection.cursor(dictionary=True)
+    condition_data=''
+    request_condition=''
+    for key,value in condition.items():
+        if isinstance(value, str):
+            condition_data += "{}={}".format(key, value)
+            request_condition=value
+    if request_condition == 'all':
+        sql_query="SELECT {} FROM {}".format(fields, tablename)
+    else:
+        sql_query="SELECT {} FROM {} WHERE {}".format(fields, tablename, condition_data)
+    print(sql_query)
+    try:
+        my_database.execute(sql_query)
+        output=my_database.fetchall()
+    except:
+        output = {"Error":"No Data Recieved or Error Occured"}
+    return output
+
+#Delete (Means update status) with condition anything(0,1) to 9 for any table
+
+def updatevaluesindb(condition, updatestatement, tablename):
+    my_database = db_connection.cursor()
+    sql_statement = "UPDATE "  + tablename + " SET " + updatestatement + " WHERE " + condition + ""
+    print(sql_statement)
+    try:
+        my_database.execute(sql_statement)
+        db_connection.commit()
+        retval = "Success"
+    except:
+        retval = "Failed"
+    return retval
+
+def insertintodb(condition, fields, values, tablename):
+    my_database = db_connection.cursor()
+    sql_statement = "INSERT INTO " + tablename + "(" + fields + ") VALUES(" + values + ") WHERE " + condition + ""
+    try:
+        my_database.execute(sql_statement)
+        db_connection.commit()
+        retval = "Success"
+    except:
+        retval = "Failed"
+    db_connection.close()
+    return retval
+
+def insertintodbwocondition(fields, values, tablename):
+    my_database = db_connection.cursor()
+    sql_statement = "INSERT INTO " + tablename + "(" + fields + ") VALUES(" + values + ")"
+    print(sql_statement)
+    try:
+        my_database.execute(sql_statement)
+        db_connection.commit()
+        retval = "Success"
+    except:
+        retval = "Failed"
+    #db_connection.close()
+    return retval
+
+def getfromdbwithcondition(condition, fields, tablename):
+    # my_database = db_connection.cursor()
+    my_database = db_connection.cursor(dictionary = True)
+    sql_statement = "SELECT "  + fields + " from " + tablename + " WHERE " + condition + ""
+    print(sql_statement)
+    try:
+        my_database.execute(sql_statement)
+        output = my_database.fetchall()
+    except:
+        output = {"Error":"No data recieved or error occured"}
+    db_connection.close()
+    return output
+
+def getfromdbwocondition(fields, tablename):
+    my_database = db_connection.cursor(dictionary = True)
+    sql_statement = "SELECT "  + fields + " from " + tablename + ""
+    print(sql_statement)
+    try:
+        my_database.execute(sql_statement)
+        output = my_database.fetchall()
+    except:
+        output = {"Error":"No data recieved or error occured"}
+    db_connection.close()
+    return output
+
+def getfromdbwoconditiongroupBy(fields, tablename):
+    my_database = db_connection.cursor(dictionary = True)
+    sql_statement = "SELECT "  + fields + " from " + tablename  + " GROUP BY" + fields + ""
+    print(sql_statement)
+    try:
+        my_database.execute(sql_statement)
+        output = my_database.fetchall()
+    except:
+        output = {"Error":"No data recieved or error occured"}
+    db_connection.close()
+    return output
+
+def getfromdbwithconditiongroupBy(condition, fields, tablename):
+    # my_database = db_connection.cursor()
+    my_database = db_connection.cursor(dictionary = True)
+    sql_statement = "SELECT " + fields +  " from" + tablename +  " WHERE" + condition + " GROUP BY" + fields + ""
+    print(sql_statement)
+    try:
+        my_database.execute(sql_statement)
+        output = my_database.fetchall()
+    except:
+        output = {"Error":"No data recieved or error occured"}
+    db_connection.close()
+    return output
+
+def unionwocondition(fields, tablename1, tablename2):
+    # my_database = db_connection.cursor()
+    my_database = db_connection.cursor(dictionary = True)
+    sql_statement = "SELECT" + fields + " from" +  tablename1 + " UNION" + " SELECT" + fields + " from" + tablename2 + ""
+    print(sql_statement)
+    try:
+        my_database.execute(sql_statement)
+        output = my_database.fetchall()
+    except:
+        output = {"Error":"No data recieved or error occured"}
+    db_connection.close()
+    return output
+
+def unionwithcondition(fields, condition, tablename1, tablename2):
+    # my_database = db_connection.cursor()
+    my_database = db_connection.cursor(dictionary = True)
+    sql_statement = "SELECT" + fields + " from" +  tablename1 + " WHERE" + condition + "UNION" + " SELECT" + fields + " from" + tablename2 + " WHERE" + condition + ""
+    print(sql_statement)
+    try:
+        my_database.execute(sql_statement)
+        output = my_database.fetchall()
+    except:
+        output = {"Error":"No data recieved or error occured"}
+    db_connection.close()
+    return output
+
+def groupbyhavingorderby(fields, condition, tablename):
+    # my_database = db_connection.cursor()
+    sql_statement = "SELECT" + fields + "FROM" + tablename + "GROUP BY" + fields + "HAVING" + condition + "ORDER BY" + fields + "DESC" + ""
+    my_database = db_connection.cursor(dictionary = True)
+    print(sql_statement)
+    try:
+        my_database.execute(sql_statement)
+        output = my_database.fetchall()
+    except:
+        output = {"Error":"No data recieved or error occured"}
+    db_connection.close()
+    return output
+
+def insertselectwhereorderby(fields, condition, tablename1, tablename2):
+    # my_database = db_connection.cursor()
+    sql_statement = "INSERT INTO" + tablename1 + " SELECT" + fields + " from" + tablename2 + " WHERE" + condition + "ORDER  BY" + fields + "DESC" + ""
+    my_database = db_connection.cursor(dictionary = True)
+    print(sql_statement)
+    try:
+        my_database.execute(sql_statement)
+        output = my_database.fetchall()
+    except:
+        output = {"Error":"No data recieved or error occured"}
+    db_connection.close()
+    return output
+
+def insertselectwhere(fields, condition, tablename1, tablename2):
+    # my_database = db_connection.cursor()
+    sql_statement = "INSERT INTO" + tablename1 + "SELECT" + fields + "FROM" + tablename2 + "WHERE" + condition + ""
+    my_database = db_connection.cursor(dictionary = True)
+    print(sql_statement)
+    try:
+        my_database.execute(sql_statement)
+        output = my_database.fetchall()
+    except:
+        output = {"Error":"No data recieved or error occured"}
+    db_connection.close()
+    return output
+def getfromdbwithconditionrange(fields,tablename,columnname,value_1,value_2):
+    my_database = db_connection.cursor(dictionary = True)
+    sql_statement="SELECT {} FROM {} WHERE {} BETWEEN {} AND {}".format(fields,tablename,columnname,value_1,value_2)
+    print(sql_statement)
+    try:
+        my_database.execute(sql_statement)
+        output = my_database.fetchall()
+    except:
+        output = {"Error":"No data recieved or error occured"}
+    # db_connection.close()
+    return output
+def getfromdbwoorderby(fields,tablename,order_by):
+    my_database = db_connection.cursor(dictionary = True)
+    sql_statement="SELECT {} FROM {} ORDER BY {}".format(fields,tablename,order_by)
+    print(sql_statement)
+    try:
+        my_database.execute(sql_statement)
+        output = my_database.fetchall()
+    except:
+        output = {"Error":"No data recieved or error occured"}
+    # db_connection.close()
+    return output
+def getfromdbwoalias(old_columnname,new_columnname,tablename,):
+    my_database = db_connection.cursor(dictionary = True)
+    sql_statement="SELECT {} FROM {} AS {}".format(old_columnname,new_columnname,tablename)
+    print(sql_statement)
+    try:
+        my_database.execute(sql_statement)
+        output = my_database.fetchall()
+    except:
+        output = {"Error":"No data recieved or error occured"}
+    # db_connection.close()
+    return output
+def getfromdbwithconditionhaving(fields,tablename,columnname,condition):
+    my_database = db_connection.cursor(dictionary = True)
+    sql_statement="SELECT {} FROM {} WHERE {} GROUP BY {} HAVING {} ORDER BY {}".format(fields,tablename,columnname,condition)
+    try:
+        my_database.execute(sql_statement)
+        output = my_database.fetchall()
+    except:
+        output = {"Error":"No data recieved or error occured"}
+    # db_connection.close()
+    return output
+def getfromdbinnerjoinwithorderby(fields,tableName,columnName,condition,order_by):
+    my_database = db_connection.cursor(dictionary = True)
+    sql_statement="SELECT {} FROM {} INNER JOIN {} ON {} WHERE {} ORDER BY {}".format(fields,tableName,columnName,condition,order_by)
+    try:
+        my_database.execute(sql_statement)
+        output = my_database.fetchall()
+    except:
+        output = {"Error":"No data recieved or error occured"}
+    # db_connection.close()
+    return output
+
+def getfromdbwithExists(columnname,tablename,condition):
+    my_database = db_connection.cursor(dictionary = True)
+    sql_statement="SELECT {} FROM {} WHERE EXISTS {}".format(columnname,tablename,condition)
+    try:
+        my_database.execute(sql_statement)
+        output = my_database.fetchall()
+    except:
+        output = {"Error":"No data recieved or error occured"}
+    # db_connection.close()
+    return output
+def getfromdbwithand(fields,columnname,tablename,condition):
+    my_database = db_connection.cursor(dictionary = True)
+    sql_statement="SELECT {} FROM {} WHERE {} AND {}".format(fields,columnname,tablename,condition)
+    try:
+        my_database.execute(sql_statement)
+        output = my_database.fetchall()
+    except:
+        output = {"Error":"No data recieved or error occured"}
+    # db_connection.close()
+    return output
+
+def getfromdbwithor(fields,columnname,tablename,condition):
+    my_database = db_connection.cursor(dictionary = True)
+    sql_statement="SELECT {} FROM {} WHERE {} OR {}".format(fields,columnname,tablename,condition)
+    try:
+        my_database.execute(sql_statement)
+        output = my_database.fetchall()
+    except:
+        output = {"Error":"No data recieved or error occured"}
+    # db_connection.close()
+    return output
+def getfromdbwithnot(fields,columnname,tablename,condition):
+    my_database = db_connection.cursor(dictionary = True)
+    sql_statement="SELECT {} FROM {} WHERE {} NOT {}".format(fields,columnname,tablename,condition)
+    try:
+        my_database.execute(sql_statement)
+        output = my_database.fetchall()
+    except:
+        output = {"Error":"No data recieved or error occured"}
+    # db_connection.close()
+    return output
+
+def getfromdbwithconditionin(fields,tablename,columnname,values):
+    my_database = db_connection.cursor(dictionary = True)
+    sql_statement="SELECT {} FROM {} WHERE {} IN {}".format(fields,columnname,tablename,values)
+    print(sql_statement)
+    try:
+        my_database.execute(sql_statement)
+        output = my_database.fetchall()
+    except:
+        output = {"Error":"No data recieved or error occured"}
+    # db_connection.close()
+    return output
+
+
+def innerJoinwithCondition(fields, tablename1,tabelname2,condition):
+    my_database = db_connection.cursor(dictionary = True) 
+    sql_statement = "SELECT "  + fields + " from " + tablename1 + "" +" INNER JOIN " +tabelname2 +" ON " +condition
+    print(sql_statement)
+    try:
+        my_database.execute(sql_statement)
+        output = my_database.fetchall()
+    except:
+        output = {"Error":"No data recieved or error occured"}
+    db_connection.close()
+    return output
+
+def leftJoinwithCondition(fields, tablename1,tabelname2,condition):
+    my_database = db_connection.cursor(dictionary = True) 
+    sql_statement = "SELECT "  + fields + " from " + tablename1 + "" +"LEFT JOIN" +""+tabelname2 +" ON " +condition+""
+    print(sql_statement)
+    try:
+        my_database.execute(sql_statement)
+        output = my_database.fetchall()
+    except:
+        output = {"Error":"No data recieved or error occured"}
+    db_connection.close()
+    return output
+
+def rightJoinwithCondition(fields, tablename1,tabelname2,condition):
+    my_database = db_connection.cursor(dictionary = True) 
+    sql_statement = "SELECT "  + fields + " from " + tablename1 + "" +"RIGHT JOIN"+""+tabelname2 +"ON" +condition+""
+    print(sql_statement)
+    try:
+        my_database.execute(sql_statement)
+        output = my_database.fetchall()
+    except:
+        output = {"Error":"No data recieved or error occured"}
+    db_connection.close()
+    return output
+
+def fullOuterJoinwithCondition(fields, tablename1,tabelname2,condition):
+    my_database = db_connection.cursor(dictionary = True) 
+    sql_statement = "SELECT "  + fields + " from " + tablename1 + "" +"FULL OUTER JOIN" +tabelname2 +"ON" +condition
+    print(sql_statement)
+    try:
+        my_database.execute(sql_statement)
+        output = my_database.fetchall()
+    except:
+        output = {"Error":"No data recieved or error occured"}
+    db_connection.close()
+    return output
+
+def innerLeftJoinwithCondition(fields, tablename1,tabelname2,condition,condition2):
+    my_database = db_connection.cursor(dictionary = True) 
+    sql_statement = "SELECT "  + fields + " from " + tablename1 + "" +"INNER JOIN" +tabelname2 +"ON" +condition + "" +"LEFT JOIN" +""+tabelname2 +"ON" +condition2+""
+    
+    print(sql_statement)
+    try:
+        my_database.execute(sql_statement)
+        output = my_database.fetchall()
+    except:
+        output = {"Error":"No data recieved or error occured"}
+    db_connection.close()
+    return output
+
+def innerRightJoinwithCondition(fields, tablename1,tabelname2,condition,condition2):
+    my_database = db_connection.cursor(dictionary = True) 
+    sql_statement = "SELECT "  + fields + " from " + tablename1 + "" +"INNER JOIN" +tabelname2 +"ON" +condition + "" +"RIGHT JOIN" +""+tabelname2 +"ON" +condition2+""
+    print(sql_statement)
+    try:
+        my_database.execute(sql_statement)
+        output = my_database.fetchall()
+    except:
+        output = {"Error":"No data recieved or error occured"}
+    db_connection.close()
+    return output
+
+def leftRightJoinwithCondition(fields, tablename1,tabelname2,condition,condition2):
+    my_database = db_connection.cursor(dictionary = True) 
+    sql_statement = "SELECT "  + fields + " from " + tablename1 + "" +"LEFT JOIN" +tabelname2 +"ON" +condition + "" +"RIGHT JOIN" +""+tabelname2 +"ON" +condition2+""    
+    print(sql_statement)
+    try:
+        my_database.execute(sql_statement)
+        output = my_database.fetchall()
+    except:
+        output = {"Error":"No data recieved or error occured"}
+    db_connection.close()
+    return output
+
+def fullOuterRightJoinwithCondition(fields, tablename1,tabelname2,condition,condition2):
+    my_database = db_connection.cursor(dictionary = True) 
+    sql_statement = "SELECT "  + fields + " from " + tablename1 + "" +"FULL OUTER JOIN" +tabelname2 +"ON" +condition + "" +"RIGHT JOIN" +""+tabelname2 +"ON" +condition2+""    
+    print(sql_statement)
+    try:
+        my_database.execute(sql_statement)
+        output = my_database.fetchall()
+    except:
+        output = {"Error":"No data recieved or error occured"}
+    db_connection.close()
+    return output
+
+def leftJoinwithOutCondition(fields, tablename1,tabelname2,):
+    my_database = db_connection.cursor(dictionary = True) 
+    sql_statement = "SELECT "  + fields + " from " + tablename1 + "" +"LEFT JOIN" +""+tabelname2 
+    print(sql_statement)
+    try:
+        my_database.execute(sql_statement)
+        output = my_database.fetchall()
+    except:
+        output = {"Error":"No data recieved or error occured"}
+    db_connection.close()
+    return output
+
+def rightJoinwithOutCondition(fields, tablename1,tabelname2):
+    my_database = db_connection.cursor(dictionary = True) 
+    sql_statement = "SELECT "  + fields + " from " + tablename1 + "" +"RIGHT JOIN"+""+tabelname2
+    print(sql_statement)
+    try:
+        my_database.execute(sql_statement)
+        output = my_database.fetchall()
+    except:
+        output = {"Error":"No data recieved or error occured"}
+    db_connection.close()
+    return output
+
+def fullOuterJoinwithoutcondition(fields, tablename1,tabelname2):
+    my_database = db_connection.cursor(dictionary = True) 
+    sql_statement = "SELECT "  + fields + " from " + tablename1 + "" +"FULL OUTER JOIN" +tabelname2
+    print(sql_statement)
+    try:
+        my_database.execute(sql_statement)
+        output = my_database.fetchall()
+    except:
+        output = {"Error":"No data recieved or error occured"}
+    db_connection.close()
+    return output
+
+'''

core/tablesdict.py

@@ -0,0 +1,46 @@
+users_table=["id","dbuserstype","dbuserid","dbusersname","dbusersemail","dbusersdp","dbusersrole","dbusernameid","dbpasswordid","status"]
+dbtype_table=["id","dbtypename","dbtypeid","dbtypedesc","dbschemaid","dbcategoryid","dbinstanceid","dbnameid","status"]
+dbacl_table = ["id","dbaclname","dbuserid","dbaclid","status"]
+dbauth_table = ["id","dbauthdesc","dbauthid","status"]
+dbbilling_table = ["id","dbbillingname","dbbillingid","dbcustomerid","amount","dbbillingdate","dbbillinglastupdate","dbinvoiceid","status"]
+dbcategory_table = ["id","dbcategoryname","dbcategoryid","dbschemaid","dbcategorydesc","status"]
+dbcharges_table = ["id","dbchargename","dbchargeid","dbschemaid","status"]
+dbcity_table = ["id","dbcityname","dbcityid","dbstateid","status"]
+dbconnectionstring_table = ["id","dbconnectionstringname","dbconnectionstringid","dbusernameid","dbpasswordid","dbipaddressid","dbtypeid","status"]
+dbcollection_table = ["id","dbcollectionname","dbcollectionid","status"]
+dbcountry_table = ["id","dbcountryname","dbcountryid","dbcountrydesc","status"]
+dbcustomer_table = ["id","dbfirstname","dbcustomerid","dblastname","dbemailid","dbuserid","dbaddress","dbcreatedate","dblastupdated","dbplanid","status"]
+dbdeleteNote_table = ["id","dbdeletenotename","dbdeletenoteid","dbdeletenotedesc","status"]
+dbdeploy_table = ["id","dbdeployname","dbdeployid","dbbillingid","status"]
+dbemail_table = ["id","dbemail","dbemailid","status"]
+dbencoding_table = ["id","dbencodingdesc","dbencodingid","dbencodingname","status"]
+dbGenInvoice_table = ["id","dbgeninvoiceid","dbgeninvoicetype","dbinvoiceid","status"]
+dbgst_table = ["id","dbgstnumber","dbgstid","status"]
+dbhash_table = ["id","dbhashname","dbhashid","dbhashtype","status"]
+dbinstance_table = ["id","dbinstancename","dbinstanceid","dbportid","dbipaddressid","dbusernameid","dbpasswordid","dbschemaid","status"]
+dbinvoice_table = ["id","dbinvoicenumber","dbinvoiceid","dbinvoiceperiodstartdate","dbinvoicelineitemid","dbcustomerid","dbinvoicedate","dbinvoiceperiodenddate","dbchargeid","status"]
+dbinvoicelineitem_table = ["id","dbinvoicelineitemname","dbinvoicelineitemid","status"]
+dbipaddress_table = ["id","dbipaddressvalue","dbipaddressid","dbipaddressdesc","dbusernameid","dbpasswordid","status"]
+dbkyc_table = ["id","dbkycdesc","dbkycid","dbtypeid","status"]
+dbname_table = ["id","dbname","dbnameid","dbschemaid","dbcategoryid","status"]
+dborders_table = ["id","dborderid","dbordername","dbbillingid","dbpackageid","status"]
+dborganization_table = ["id","dborganizationname","dborganizationid","dborganizationdesc","dbpanid","status"]
+dbpackage_table = ["id","dbpackagename","dbpackageid","status"]
+dbpan_table = ["id","dbpannumber","dbpanid","dbemailid","dbphoneid","dbkycid","status"]
+dbpassword_table = ["id","dbpassword","dbpasswordid","dbpassworddesc","dbusernameid","dbcategoryid","status"]
+dbpermission_table = ["id","dbpermissionname","dbpermissionid","dbtypeid","dbaclid","status"]
+dbphone_table = ["id","dbphonenumber","dbphoneid","status"]
+dbpincode_table = ["id","dbpincode","dbpincodeid","dbcityid","dbstateid","dbcountryid","status"]
+dbplan_table = ["id","dbplanname","dbplanid","status"]
+dbplanbilling_table = ["id","dbplanbillingname","dbplanbillingid","dbpackageid","dbplanid","status"]
+dbplans_table = ["id","dbplansid","dbplansname","dbtypeid","dbbillingid","status"]
+dbpo_table = ["id","dbponumber","dbpoid","dbinvoiceid","dbbillingid","dbcustomerid","dborganizationid","status"]
+dbportnumber_table = ["id","dbportnumbername","dbportid","dbportnumbercategory","dbportnumberdesc","dbcountryid","dbpincodeid","dbusernameid","dbpasswordid","status"]
+dbprod_table = ["id","dbprodname","dbprodid","status"]
+dbrole_table = ["id","dbrolename","dbroleid","dbuserid","dbroledesc","dbpermissionid","status"]
+dbschema_table = ["id","dbschemaname","dbschemaid","dbschemadesc","dbcollectionid","dbauthid","dbencodingid","dbvariabletypeid","status"]
+dbstate_table = ["id","dbstatename","dbstateid","dbcountryid","dbstatedesc","status"]
+dbuac_table = ["id","dbuactype","dbuacid","dbroleid","dbuacname","status"]
+username_table = ["id","dbusername","dbusernameid","dbusernamedesc","dbnameid","dbcategoryid","status"]
+dbusagelimit_table = ["id","dbusagelimitmin","dbusagelimitid","dbschemaid","dborganizationid","dbroleid","dbplanid","dbusagelimitmax","status"]
+dbvariabletype_table=["id","dbvariabletypename","dbvariabletypeid","status"]