dbilayer_cassandra/core/bll/bllengine.py

from werkzeug.security import check_password_hash
from core.dbil import dbilayer
from core.modules import common
from random import randint
from hashids import Hashids
from uuid_extensions import uuid7
from core import constants
from core import tablesdict

hashids = Hashids()


serial_number_dbtype=111111111


# Register User

def performRegistration(reqData):
    if isinstance(reqData, dict):
        userData=reqData['requestdata']
        sta=dbilayer.registerUserNow('dbusers', constants.columns_users_table, userData)
        if (sta != 'Failed'):
            respsucc={"responseid": reqData['requestid'], "responsefor": "Create User Details", "responsesetto": "UI", "response": {"message": sta}}
            return respsucc
        else:
            respfail={"responseid": reqData['requestid'], "responsefor": "Create User Details", "responsesetto": "UI", "response": {"message": "Some Error in Request"}}
            return respfail
    else:
        respfail={"responseid": reqData['requestid'], "responsefor": "Create User Details", "responsesetto": "UI", "response": {"message": "Error Encountered"}}
        return respfail

# Login User

def performLoginActivity(reqData):
    response={}
    if isinstance(reqData, dict):
        userData=reqData['requestdata']
        sta=dbilayer.getUserActivity('users', '*', userData)
        print(sta, type(sta), len(sta))
        if ((isinstance(sta,dict)) and (len(sta)>1)):
            username=sta['username']
            userpassword=sta['userpassword']
            if (username and userpassword):
                if ((username == userData['username']) and (check_password_hash(userpassword,userData['userpassword']))):
                    response={"message": "User Loggedin Successfully", "user_details": sta}
                else:
                    response={"message": "Password Doesn't Matched"}
            else:
                response={"message": "Username or Password Doesn't Matched"}
        else:
            response={"message": "Username Doesn't exist"}
    else:
        response={"message": "Error Encountered"}
    return response

# Generate_unique_names

def generate_unique_ids(name,empty_id_name,reqData, tablename):
    global serial_number_dbtype
    if (tablename == 'dbtype'):
        serial_number=serial_number_dbtype
    # elif (tablename == 'dbtype'):
    #     serial_number=serial_number_dbtype
    # elif (tablename == 'pagelayoutnprops'):
    #     serial_number=serial_number_pages
    # elif (tablename == 'projects'):
    #     serial_number=serial_number_projects
    # elif (tablename == 'propmetrics'):
    #     serial_number=serial_number_propmetrics
    # else:
    #     serial_number=serial_number_props
    
    data_to_insert=reqData['requestdata']
    if (tablename == 'propset'):
        name=name
    else:
        name=data_to_insert[name]

    incremented_serial_number=serial_number+1

    hashid=hashids.encode(incremented_serial_number)

    id=name[:4] + hashid
    print(id, incremented_serial_number)
    print("first serial number", serial_number)
    all_ids_stored=dbilayer.returnspecificlist(empty_id_name, tablename)
    id_created=False
    index_for_stored_names_access=1
    while (not(id_created)):
        if id not in all_ids_stored:
            data_to_insert[empty_id_name]=id
            id_created=True
            all_ids_stored.append(id)
        elif (len(all_ids_stored) > 0):
            previous_last_stored_hashed_number=all_ids_stored[-index_for_stored_names_access][4:]
            print(previous_last_stored_hashed_number)
            previous_last_stored_number=hashids.decode(previous_last_stored_hashed_number)
            print(previous_last_stored_number)
            incremented_serial_number=previous_last_stored_number[0]+1
            serial_number=incremented_serial_number

            hashid=hashids.encode(incremented_serial_number)
            id=name[:4] + hashid

            if id not in all_ids_stored:
                data_to_insert[empty_id_name]=id
                id_created=True
                all_ids_stored.append(id)
            print("first elif")
        elif (index_for_stored_names_access == len(all_ids_stored)):
            while (not(id_created)):
                uuid_random_number=uuid7()
                id=name[:4] + str(uuid_random_number)[:6]
                if id not in all_ids_stored:
                    data_to_insert[empty_id_name]=id
                    id_created=True
                    all_ids_stored.append(id)
                    break
        index_for_stored_names_access += 1
    serial_number=incremented_serial_number
    print("last final serial number", serial_number)
    if  (serial_number >= 111111111):
        serial_number_dbtype=serial_number
    # elif (serial_number < 300000):
    #     serial_number_layout=serial_number
    # elif (serial_number < 500000):
    #     serial_number_pages=serial_number
    # elif (serial_number < 700000):
    #     serial_number_projects = serial_number
    # elif (serial_number < 900000):
    #     serial_number_propmetrics=serial_number
    # else:
    #     serial_number_props=serial_number

    return data_to_insert, all_ids_stored
  


## Functions for DBACL
# 1.1. Read All without condition
def dbacl_processreadall(reqData):
    if isinstance(reqData, dict):
        if reqData['requestdata']['dbaclid'] == "all":
            sta=dbilayer.readallWithoutCondition('dbacl', '*',tablesdict.dbacl_table)
            #sta=common.list2dict(sta)
            if (len(sta) >= 1):
                respsucc={"responseid": reqData['requestid'], "responsefor": "Read all", "responsesetto": reqData['requestsrc'], "response": {"message": sta}}
                return respsucc
            else:
                respfail={"responseid": reqData['requestid'], "responsefor": "Read all", "responsesetto": reqData['requestsrc'], "response": {"message": "No data Received!"}}
                return respfail
        else:
            respfail={"responseid": reqData['requestid'], "responsefor": "Read all", "responsesetto": reqData['requestsrc'], "response": {"message": "Some error in request"}}
            return respfail    
    else:
        respfail={"responseid": reqData['requestid'], "responsefor": "Read all", "responsesetto": reqData['requestsrc'], "response": {"message": "Some error in request"}}
        return respfail
    
# 1.2. Read Multiple Conditional
def dbacl_processreadmanycond(reqData):
    if isinstance(reqData, dict):
        condition_data=reqData['requestdata']
        condition_data = "status = '{}'".format(condition_data["status"])
        print(condition_data)
        print()
        print()
        print()
        print()
        print()
        sta=dbilayer.readOneWithcondition('dbacl', '*', condition_data,tablesdict.dbacl_table)
        if (len(sta) >= 1):
            #sta=common.list2dict(sta)
            respsucc={"responseid": reqData['requestid'], "responsefor": "Read all with condition", "responsesetto": reqData['requestsrc'], "response": {"message": sta}}
            return respsucc
        else:
            respfail={"responseid": reqData['requestid'], "responsefor": "Read all with condition", "responsesetto": reqData['requestsrc'], "response":{"message": "No data received!"}}
            return respfail
    else:
        respfail={"responseid": reqData['requestid'], "responsefor": "Read all with condition", "responsesetto": reqData['requestsrc'], "response": {"message": "Error Encountered"}}
        return respfail
    
# 1.3. Read One Conditional
def dbacl_processreadonecond(reqData):
    if isinstance(reqData, dict):
        #condition_data=reqData['requestdata']
        #dbaclid=condition_data['dbaclid']
        #data=tuple(condition_data.values())
        #print(data)
        condition_data=reqData['requestdata']
        condition = "dbaclid = {} AND status = '{}'".format(condition_data["dbaclid"], condition_data["status"])
        sta=dbilayer.readOneWithcondition('dbacl', '*', condition,tablesdict.dbusagelimit_table)
        print(sta)

        #condition = "dbaclid = {}".format(dbaclid)
        #print(condition)
        #sta=dbilayer.readOneWithcondition('dbacl', '*', condition,constants.columns_dbacl_table)
        #print(sta)
        #sta=common.list2dict(sta)
        if (len(sta) >= 1):
            respsucc={"responseid": reqData['requestid'], "responsefor": "Read one", "responsesetto": reqData['requestsrc'], "response": {"message": sta}}
            return respsucc
        else:
            respfail={"responseid": reqData['requestid'], "responsefor": "Read one", "responsesetto": reqData['requestsrc'], "response": {"message": "No data Received!"}}
            return respfail
    else:
        respfail={"responseid": reqData['requestid'], "responsefor": "Read one", "responsesetto": reqData['requestsrc'], "response": {"message": "Error Encountered"}}
        return respfail    

# 1.4. Create
def dbacl_processcreate(reqData):
    if isinstance(reqData, dict):
        #data_to_insert, ids_of_stored = generate_unique_ids('pagename','pagelayoutpropid',reqData, 'pagelayoutnprops')
        #print("all stored ids in db", data_to_insert, ids_of_stored)
        data_to_insert = reqData["requestdata"]
        print(data_to_insert)
        data=tuple(data_to_insert.values())
        print(data)
        #data = data.replace('"',"'")
       # data="'" + data + "'"        
        sta=dbilayer.insertIntoDBWithoutCondition('dbacl',constants.columns_dbacl_table, data)
        if(sta == "Success"):
            respsucc={"responseid": reqData['requestid'], "responsefor": "Create", "responsesetto": reqData['requestsrc'], "response": {"message": "Success"}}
            return respsucc
        else:
            respfail={"responseid": reqData['requestid'], "responsefor": "Create", "responsesetto": reqData['requestsrc'], "response": {"message": "Some Error in Request"}}
            return respfail
    else:
        respfail={"responseid": reqData['requestid'], "responsefor": "Create", "responsesetto": reqData['requestsrc'], "response": {"message": "Error Encountered"}}
        return respfail
    
 #1.5. Delete One Conditional
def dbacl_processdeleteonecond(reqData):
    if reqData['requestdata']['dbaclid']:
        data = reqData['requestdata']['dbaclid']
        sta = dbilayer.updateValuesIndb('dbacl',"status = '9'" ,"dbaclid = {}".format(data))
        print(sta)
        if(sta == "Success"):
            respsucc = {"responseid": reqData['requestid'], "responsefor":"dbacl_processdeleteonecond","responseto":"UI","responsedata": {"message":"Deleted Successfully"}}
            return  respsucc
        elif(sta == 'Failed'):
            respfail = {"responseid": reqData['requestid'], "responsefor":"dbacl_processdeleteonecond","responseto":"UI","responsedata": {"message":"Delete request Failed"}}
            return  respfail
    else:
        respfail = {"responseid": reqData['requestid'], "responsefor":"dbacl_processdeleteonecond","responseto":"UI","responsedata": {"message":"Error in Request"}}
        return  respfail   
    
#1.6. Update One Conditional
def dbacl_processupdateonecond(reqData):
    if isinstance(reqData, dict):
        data=reqData['requestdata']
        dbaclname = data['dbaclname']
        dbuserid = data['dbuserid']
        dbaclid = data['dbaclid']
        status = data['status']
        #updateStatement = "dbaclname = '{}', dbuserid = {},dbaclid = {},status = '{}'".format(dbaclname,dbuserid,dbaclid,status)
        updateStatement = "dbaclname = '{}', dbuserid = {}".format(dbaclname, dbuserid)
        condition = "dbaclid = {}".format(dbaclid)
        print(condition)
        print()
        print()
        print()
        sta = dbilayer.updateValuesIndb('dbacl', updateStatement, condition)
        print(sta)
        if(sta == "Success"):
            respsucc = {"responseid": reqData['requestid'], "responsefor":"Update data","responsesetto": reqData['requestsrc'],"responsedata": {"message":"Success"}}
            return  respsucc
        elif(sta == 'Failed'):
            respfail = {"responseid": reqData['requestid'], "responsefor":"Update data","responsesetto": reqData['requestsrc'],"responsedata": {"message":"Failed"}}
            return  respfail
    else:
        respfail = {"responseid": reqData['requestid'], "responsefor":"Update data","responsesetto": reqData['requestsrc'],"responsedata": {"message":"Error in Request"}}
        return  respfail

#1.7. Update All
def dbacl_processupdateall(req):
     pass



## Functions for DBAUTH
# 1.1. Read All without condition
def dbauth_processreadall(reqData):
    if isinstance(reqData, dict):
        if reqData['requestdata']['dbauthid'] == "all":
            sta=dbilayer.readallWithoutCondition('dbauth', '*',tablesdict.dbauth_table)
            #sta=common.list2dict(sta)
            if (len(sta) >= 1):
                respsucc={"responseid": reqData['requestid'], "responsefor": "Read all", "responsesetto": reqData['requestsrc'], "response": {"message": sta}}
                return respsucc
            else:
                respfail={"responseid": reqData['requestid'], "responsefor": "Read all", "responsesetto": reqData['requestsrc'], "response": {"message": "No data Received!"}}
                return respfail
        else:
            respfail={"responseid": reqData['requestid'], "responsefor": "Read all", "responsesetto": reqData['requestsrc'], "response": {"message": "Some error in request"}}
            return respfail    
    else:
        respfail={"responseid": reqData['requestid'], "responsefor": "Read all", "responsesetto": reqData['requestsrc'], "response": {"message": "Some error in request"}}
        return respfail
    
# 1.2. Read Multiple Conditional
def dbauth_processreadmanycond(reqData):
    if isinstance(reqData, dict):
        condition_data=reqData['requestdata']
        condition_data = "status = '{}'".format(condition_data["status"])
        sta=dbilayer.readOneWithcondition('dbauth', '*', condition_data,tablesdict.dbauth_table)
        if (len(sta) >= 1):
            #sta=common.list2dict(sta)
            respsucc={"responseid": reqData['requestid'], "responsefor": "Read all with condition", "responsesetto": reqData['requestsrc'], "response": {"message": sta}}
            return respsucc
        else:
            respfail={"responseid": reqData['requestid'], "responsefor": "Read all with condition", "responsesetto": reqData['requestsrc'], "response":{"message": "No data received!"}}
            return respfail
    else:
        respfail={"responseid": reqData['requestid'], "responsefor": "Read all with condition", "responsesetto": reqData['requestsrc'], "response": {"message": "Error Encountered"}}
        return respfail
    
# 1.3. Read One Conditional
def dbauth_processreadonecond(reqData):
    if isinstance(reqData, dict):
        condition_data=reqData['requestdata']
        condition = "dbauthid = {} AND status = '{}'".format(condition_data["dbauthid"], condition_data["status"])
        sta=dbilayer.readOneWithcondition('dbauth','*', condition,tablesdict.dbauth_table)
        print(sta)
        #sta=common.list2dict(sta)
        if (len(sta) >= 1):
            respsucc={"responseid": reqData['requestid'], "responsefor": "Read one", "responsesetto": reqData['requestsrc'], "response": {"message": sta}}
            return respsucc
        else:
            respfail={"responseid": reqData['requestid'], "responsefor": "Read one", "responsesetto": reqData['requestsrc'], "response": {"message": "No data Received!"}}
            return respfail
    else:
        respfail={"responseid": reqData['requestid'], "responsefor": "Read one", "responsesetto": reqData['requestsrc'], "response": {"message": "Error Encountered"}}
        return respfail    

# 1.4. Create
def dbauth_processcreate(reqData):
    if isinstance(reqData, dict):
        #data_to_insert, ids_of_stored = generate_unique_ids('pagename','pagelayoutpropid',reqData, 'pagelayoutnprops')
        #print("all stored ids in db", data_to_insert, ids_of_stored)
        data_to_insert = reqData["requestdata"]
        print(data_to_insert)
        data=tuple(data_to_insert.values())
        print()
        print()
        print()
        print()
        print()
        #new_data=x.replace(''','')
        print(data)
    

        '''
        data_to_insert = reqData["requestdata"]
        print(data_to_insert)
        data='","'.join(data_to_insert.values())
        data = data.replace('"',"'")
        data="'" + data + "'" '''
        sta=dbilayer.insertIntoDBWithoutCondition('dbauth',constants.column_dbauth_table,data)
        if(sta == "Success"):
            respsucc={"responseid": reqData['requestid'], "responsefor": "Create", "responsesetto": reqData['requestsrc'], "response": {"message": "Success"}}
            return respsucc
        else:
            respfail={"responseid": reqData['requestid'], "responsefor": "Create", "responsesetto": reqData['requestsrc'], "response": {"message": "Some Error in Request"}}
            return respfail
    else:
        respfail={"responseid": reqData['requestid'], "responsefor": "Create", "responsesetto": reqData['requestsrc'], "response": {"message": "Error Encountered"}}
        return respfail
    
 #1.5. Delete One Conditional
def dbauth_processdeleteonecond(reqData):
    if reqData['requestdata']['dbauthid']:
        data = reqData['requestdata']['dbauthid']
        sta = dbilayer.updateValuesIndb('dbauth',"status ='9'" ,"dbauthid = {}".format(data))
        print(sta)
        if(sta == "Success"):
            respsucc = {"responseid": reqData['requestid'], "responsefor":"dbauth_processdeleteonecond","responseto":"UI","responsedata": {"message":"Deleted Successfully"}}
            return  respsucc
        elif(sta == 'Failed'):
            respfail = {"responseid": reqData['requestid'], "responsefor":"dbauth_processdeleteonecond","responseto":"UI","responsedata": {"message":"Delete request Failed"}}
            return  respfail
    else:
        respfail = {"responseid": reqData['requestid'], "responsefor":"dbauth_processdeleteonecond","responseto":"UI","responsedata": {"message":"Error in Request"}}
        return  respfail   
    
#1.6. Update One Conditional
def dbauth_processupdateonecond(reqData):
    if isinstance(reqData, dict):
        data=reqData['requestdata']
        dbuserid = data['dbauthid']
        dbauthid = data['dbauthdesc']
        status = data['status']
        updateStatement = "dbauthdesc = '{}',status = '{}'".format(dbauthid,status)
        condition = "dbauthid = {}".format(dbuserid)
        sta = dbilayer.updateValuesIndb('dbauth', updateStatement, condition)
        print(sta)
        if(sta == "Success"):
            respsucc = {"responseid": reqData['requestid'], "responsefor":"Update data","responsesetto": reqData['requestsrc'],"responsedata": {"message":"Success"}}
            return  respsucc
        elif(sta == 'Failed'):
            respfail = {"responseid": reqData['requestid'], "responsefor":"Update data","responsesetto": reqData['requestsrc'],"responsedata": {"message":"Failed"}}
            return  respfail
    else:
        respfail = {"responseid": reqData['requestid'], "responsefor":"Update data","responsesetto": reqData['requestsrc'],"responsedata": {"message":"Error in Request"}}
        return  respfail

#1.7. Update All
def dbauth_processupdateall(req):
     pass







## Functions for DBUSAGELIMIT
# 1.1. Read All without condition
def dbusagelimt_processreadall(reqData):
    if isinstance(reqData, dict):
        if reqData['requestdata']['dbusagelimitid'] == "all":
            sta=dbilayer.readallWithoutCondition('dbusagelimit', '*',tablesdict.dbusagelimit_table)
            #sta=common.list2dict(sta)
            if (len(sta) >= 1):
                respsucc={"responseid": reqData['requestid'], "responsefor": "Read all", "responsesetto": reqData['requestsrc'], "response": {"message": sta}}
                return respsucc
            else:
                respfail={"responseid": reqData['requestid'], "responsefor": "Read all", "responsesetto": reqData['requestsrc'], "response": {"message": "No data Received!"}}
                return respfail
        else:
            respfail={"responseid": reqData['requestid'], "responsefor": "Read all", "responsesetto": reqData['requestsrc'], "response": {"message": "Some error in request"}}
            return respfail    
    else:
        respfail={"responseid": reqData['requestid'], "responsefor": "Read all", "responsesetto": reqData['requestsrc'], "response": {"message": "Some error in request"}}
        return respfail
    
# 1.2. Read Multiple Conditional
def dbusagelimit_processreadmanycond(reqData):
    if isinstance(reqData, dict):
        condition_data=reqData['requestdata']
        condition_data = "status = '{}'".format(condition_data["status"])
        sta=dbilayer.readOneWithcondition('dbusagelimit', '*', condition_data,tablesdict.dbusagelimit_table)
        if (len(sta) >= 1):
            #sta=common.list2dict(sta)
            respsucc={"responseid": reqData['requestid'], "responsefor": "Read all with condition", "responsesetto": reqData['requestsrc'], "response": {"message": sta}}
            return respsucc
        else:
            respfail={"responseid": reqData['requestid'], "responsefor": "Read all with condition", "responsesetto": reqData['requestsrc'], "response":{"message": "No data received!"}}
            return respfail
    else:
        respfail={"responseid": reqData['requestid'], "responsefor": "Read all with condition", "responsesetto": reqData['requestsrc'], "response": {"message": "Error Encountered"}}
        return respfail
    
# 1.3. Read One Conditional
def dbusagelimit_processreadonecond(reqData):
    if isinstance(reqData, dict):
        condition_data=reqData['requestdata']
        condition = "dbusagelimitid = {} AND status = '{}'".format(condition_data["dbusagelimitid"], condition_data["status"])
        sta=dbilayer.readOneWithcondition('dbusagelimit', '*', condition,tablesdict.dbusagelimit_table)
        print(sta)
        #sta=common.list2dict(sta)
        if (len(sta) >= 1):
            respsucc={"responseid": reqData['requestid'], "responsefor": "Read one", "responsesetto": reqData['requestsrc'], "response": {"message": sta}}
            return respsucc
        else:
            respfail={"responseid": reqData['requestid'], "responsefor": "Read one", "responsesetto": reqData['requestsrc'], "response": {"message": "No data Received!"}}
            return respfail
    else:
        respfail={"responseid": reqData['requestid'], "responsefor": "Read one", "responsesetto": reqData['requestsrc'], "response": {"message": "Error Encountered"}}
        return respfail    

# 1.4. Create
def dbusagelimit_processcreate(reqData):
    if isinstance(reqData, dict):
        #data_to_insert, ids_of_stored = generate_unique_ids('pagename','pagelayoutpropid',reqData, 'pagelayoutnprops')
        #print("all stored ids in db", data_to_insert, ids_of_stored)
        data_to_insert = reqData["requestdata"]
        data=tuple(data_to_insert.values())
        sta=dbilayer.insertIntoDBWithoutCondition('dbusagelimit',constants.column_dbusagelimit_table, data)
        if(sta == "Success"):
            respsucc={"responseid": reqData['requestid'], "responsefor": "Create", "responsesetto": reqData['requestsrc'], "response": {"message": "Success"}}
            return respsucc
        else:
            respfail={"responseid": reqData['requestid'], "responsefor": "Create", "responsesetto": reqData['requestsrc'], "response": {"message": "Some Error in Request"}}
            return respfail
    else:
        respfail={"responseid": reqData['requestid'], "responsefor": "Create", "responsesetto": reqData['requestsrc'], "response": {"message": "Error Encountered"}}
        return respfail
    
 #1.5. Delete One Conditional
def dbusagelimit_processdeleteonecond(reqData):
    if reqData['requestdata']['dbusagelimitid']:
        data = reqData['requestdata']['dbusagelimitid']
        sta = dbilayer.updateValuesIndb('dbusagelimit',"status ='9'" ,"dbusagelimitid = {}".format(data))
        print(sta)
        if(sta == "Success"):
            respsucc = {"responseid": reqData['requestid'], "responsefor":"dbacl_processdeleteonecond","responseto":"UI","responsedata": {"message":"Deleted Successfully"}}
            return  respsucc
        elif(sta == 'Failed'):
            respfail = {"responseid": reqData['requestid'], "responsefor":"dbacl_processdeleteonecond","responseto":"UI","responsedata": {"message":"Delete request Failed"}}
            return  respfail
    else:
        respfail = {"responseid": reqData['requestid'], "responsefor":"dbacl_processdeleteonecond","responseto":"UI","responsedata": {"message":"Error in Request"}}
        return  respfail   
    
#1.6. Update One Conditional
def dbusagelimit_processupdateonecond(reqData):
    if isinstance(reqData, dict):
        data = reqData["requestdata"]
        dbusagelimitmin = data['dbusagelimitmin']
        dbusagelimitid = data['dbusagelimitid']
        dbschemaid = data['dbschemaid']
        dborganizationid = data['dborganizationid']
        dbroleid = data['dbroleid']
        dbplanid = data['dbplanid']
        dbusagelimitmax = data['dbusagelimitmax']
        status = data['status']
        condition = "dbusagelimitid = {}".format(dbusagelimitid)
        updateStatement = "dbusagelimitmin = {}, dbschemaid={}, dborganizationid = {}, dbroleid = {}, dbplanid = {}, dbusagelimitmax = {}, status = '{}'".format(dbusagelimitmin,dbusagelimitid,dbschemaid,dborganizationid,dbroleid, dbplanid, dbusagelimitmax,status)
        sta = dbilayer.updateValuesIndb('dbusagelimit', updateStatement, condition)
        print(sta)
        if(sta == "Success"):
            respsucc = {"responseid": reqData['requestid'], "responsefor":"Update data","responsesetto": reqData['requestsrc'],"responsedata": {"message":"Success"}}
            return  respsucc
        elif(sta == 'Failed'):
            respfail = {"responseid": reqData['requestid'], "responsefor":"Update data","responsesetto": reqData['requestsrc'],"responsedata": {"message":"Failed"}}
            return  respfail
    else:
        respfail = {"responseid": reqData['requestid'], "responsefor":"Update data","responsesetto": reqData['requestsrc'],"responsedata": {"message":"Error in Request"}}
        return  respfail

#1.7. Update All
def dbusagelimit_processupdateall(req):
     pass


## Functions for DBUSERNAME
# 1.1. Read All without condition
def dbusername_processreadall(reqData):
    if isinstance(reqData, dict):
        if reqData['requestdata']['dbusernameid'] == "all":
            sta=dbilayer.readallWithoutCondition('dbusername', '*',tablesdict.username_table)
            #sta=common.list2dict(sta)
            if (len(sta) >= 1):
                respsucc={"responseid": reqData['requestid'], "responsefor": "Read all", "responsesetto": reqData['requestsrc'], "response": {"message": sta}}
                return respsucc
            else:
                respfail={"responseid": reqData['requestid'], "responsefor": "Read all", "responsesetto": reqData['requestsrc'], "response": {"message": "No data Received!"}}
                return respfail
        else:
            respfail={"responseid": reqData['requestid'], "responsefor": "Read all", "responsesetto": reqData['requestsrc'], "response": {"message": "Some error in request"}}
            return respfail    
    else:
        respfail={"responseid": reqData['requestid'], "responsefor": "Read all", "responsesetto": reqData['requestsrc'], "response": {"message": "Some error in request"}}
        return respfail
    
# 1.2. Read Multiple Conditional
def dbusername_processreadmanycond(reqData):
    if isinstance(reqData, dict):
        condition_data=reqData['requestdata']
        condition_data = "status = '{}'".format(condition_data["status"])
        sta=dbilayer.readOneWithcondition('dbusername', '*', condition_data,tablesdict.username_table)
        if (len(sta) >= 1):
            #sta=common.list2dict(sta)
            respsucc={"responseid": reqData['requestid'], "responsefor": "Read all with condition", "responsesetto": reqData['requestsrc'], "response": {"message": sta}}
            return respsucc
        else:
            respfail={"responseid": reqData['requestid'], "responsefor": "Read all with condition", "responsesetto": reqData['requestsrc'], "response":{"message": "No data received!"}}
            return respfail
    else:
        respfail={"responseid": reqData['requestid'], "responsefor": "Read all with condition", "responsesetto": reqData['requestsrc'], "response": {"message": "Error Encountered"}}
        return respfail
    
# 1.3. Read One Conditional
def dbusername_processreadonecond(reqData):
    if isinstance(reqData, dict):
        condition_data=reqData['requestdata']
        condition = "dbusernameid = {} AND status = '{}'".format(condition_data["dbusernameid"], condition_data["status"])
        sta=dbilayer.readOneWithcondition('dbusername', '*', condition,tablesdict.username_table)
        print(sta)
        #sta=common.list2dict(sta)
        if (len(sta) >= 1):
            respsucc={"responseid": reqData['requestid'], "responsefor": "Read one", "responsesetto": reqData['requestsrc'], "response": {"message": sta}}
            return respsucc
        else:
            respfail={"responseid": reqData['requestid'], "responsefor": "Read one", "responsesetto": reqData['requestsrc'], "response": {"message": "No data Received!"}}
            return respfail
    else:
        respfail={"responseid": reqData['requestid'], "responsefor": "Read one", "responsesetto": reqData['requestsrc'], "response": {"message": "Error Encountered"}}
        return respfail    

# 1.4. Create
def dbusername_processcreate(reqData):
    if isinstance(reqData, dict):
        #data_to_insert, ids_of_stored = generate_unique_ids('pagename','pagelayoutpropid',reqData, 'pagelayoutnprops')
        #print("all stored ids in db", data_to_insert, ids_of_stored)
        data_to_insert = reqData["requestdata"]
        data=tuple(data_to_insert.values())
        sta=dbilayer.insertIntoDBWithoutCondition('dbusername',constants.column_username_table, data)
        if(sta == "Success"):
            respsucc={"responseid": reqData['requestid'], "responsefor": "Create", "responsesetto": reqData['requestsrc'], "response": {"message": "Success"}}
            return respsucc
        else:
            respfail={"responseid": reqData['requestid'], "responsefor": "Create", "responsesetto": reqData['requestsrc'], "response": {"message": "Some Error in Request"}}
            return respfail
    else:
        respfail={"responseid": reqData['requestid'], "responsefor": "Create", "responsesetto": reqData['requestsrc'], "response": {"message": "Error Encountered"}}
        return respfail
    
 #1.5. Delete One Conditional
def dbusername_processdeleteonecond(reqData):
    if reqData['requestdata']['dbusernameid']:
        data = reqData['requestdata']['dbusernameid']
        sta = dbilayer.updateValuesIndb('dbusername',"status ='9'" ,"dbusernameid = {}".format(data))
        print(sta)
        if(sta == "Success"):
            respsucc = {"responseid": reqData['requestid'], "responsefor":"dbacl_processdeleteonecond","responseto":"UI","responsedata": {"message":"Deleted Successfully"}}
            return  respsucc
        elif(sta == 'Failed'):
            respfail = {"responseid": reqData['requestid'], "responsefor":"dbacl_processdeleteonecond","responseto":"UI","responsedata": {"message":"Delete request Failed"}}
            return  respfail
    else:
        respfail = {"responseid": reqData['requestid'], "responsefor":"dbacl_processdeleteonecond","responseto":"UI","responsedata": {"message":"Error in Request"}}
        return  respfail   
    
#1.6. Update One Conditional
def dbusername_processupdateonecond(reqData):
    if isinstance(reqData, dict):
        data = reqData["requestdata"]
        dbusername = data['dbusername']
        dbusernameid = data['dbusernameid']
        dbusernamedesc = data['dbusernamedesc']
        dbnameid = data['dbnameid']
        dbcategoryid = data['dbcategoryid']
        status = data['status']
        condition = "dbusernameid = {}".format(dbusernameid)
        updateStatement = "dbusername = '{}', dbusernamedesc='{}', dbnameid = {}, dbcategoryid = {}, status = '{}'".format(dbusername,dbusernamedesc,dbnameid,dbcategoryid,status)
        sta = dbilayer.updateValuesIndb('dbusername', updateStatement, condition)
        print(sta)
        if(sta == "Success"):
            respsucc = {"responseid": reqData['requestid'], "responsefor":"Update data","responsesetto": reqData['requestsrc'],"responsedata": {"message":"Success"}}
            return  respsucc
        elif(sta == 'Failed'):
            respfail = {"responseid": reqData['requestid'], "responsefor":"Update data","responsesetto": reqData['requestsrc'],"responsedata": {"message":"Failed"}}
            return  respfail
    else:
        respfail = {"responseid": reqData['requestid'], "responsefor":"Update data","responsesetto": reqData['requestsrc'],"responsedata": {"message":"Error in Request"}}
        return  respfail

#1.7. Update All
def dbusername_processupdateall(req):
     pass

## Functions for DBuac
# 1.1. Read All without condition
def dbuac_processreadall(reqData):
    if isinstance(reqData, dict):
        if reqData['requestdata']['dbuacid'] == "all":
            sta=dbilayer.readallWithoutCondition('dbuac', '*',tablesdict.dbuac_table)
            #sta=common.list2dict(sta)
            if (len(sta) >= 1):
                respsucc={"responseid": reqData['requestid'], "responsefor": "Read all", "responsesetto": reqData['requestsrc'], "response": {"message": sta}}
                return respsucc
            else:
                respfail={"responseid": reqData['requestid'], "responsefor": "Read all", "responsesetto": reqData['requestsrc'], "response": {"message": "No data Received!"}}
                return respfail
        else:
            respfail={"responseid": reqData['requestid'], "responsefor": "Read all", "responsesetto": reqData['requestsrc'], "response": {"message": "Some error in request"}}
            return respfail    
    else:
        respfail={"responseid": reqData['requestid'], "responsefor": "Read all", "responsesetto": reqData['requestsrc'], "response": {"message": "Some error in request"}}
        return respfail
    
# 1.2. Read Multiple Conditional
def dbuac_processreadmanycond(reqData):
    if isinstance(reqData, dict):
        condition_data=reqData['requestdata']
        condition_data = "status = '{}'".format(condition_data["status"])
        sta=dbilayer.readOneWithcondition('dbuac', '*', condition_data,tablesdict.dbuac_table)
        if (len(sta) >= 1):
            #sta=common.list2dict(sta)
            respsucc={"responseid": reqData['requestid'], "responsefor": "Read all with condition", "responsesetto": reqData['requestsrc'], "response": {"message": sta}}
            return respsucc
        else:
            respfail={"responseid": reqData['requestid'], "responsefor": "Read all with condition", "responsesetto": reqData['requestsrc'], "response":{"message": "No data received!"}}
            return respfail
    else:
        respfail={"responseid": reqData['requestid'], "responsefor": "Read all with condition", "responsesetto": reqData['requestsrc'], "response": {"message": "Error Encountered"}}
        return respfail
    
# 1.3. Read One Conditional
def dbuac_processreadonecond(reqData):
    if isinstance(reqData, dict):
        condition_data=reqData['requestdata']
        condition = "dbuacid = {} AND status = '{}'".format(condition_data["dbuacid"], condition_data["status"])
        sta=dbilayer.readOneWithcondition('dbuac', '*', condition,tablesdict.dbuac_table)
        print(sta)
        #sta=common.list2dict(sta)
        if (len(sta) >= 1):
            respsucc={"responseid": reqData['requestid'], "responsefor": "Read one", "responsesetto": reqData['requestsrc'], "response": {"message": sta}}
            return respsucc
        else:
            respfail={"responseid": reqData['requestid'], "responsefor": "Read one", "responsesetto": reqData['requestsrc'], "response": {"message": "No data Received!"}}
            return respfail
    else:
        respfail={"responseid": reqData['requestid'], "responsefor": "Read one", "responsesetto": reqData['requestsrc'], "response": {"message": "Error Encountered"}}
        return respfail    

# 1.4. Create
def dbuac_processcreate(reqData):
    if isinstance(reqData, dict):
        #data_to_insert, ids_of_stored = generate_unique_ids('pagename','pagelayoutpropid',reqData, 'pagelayoutnprops')
        #print("all stored ids in db", data_to_insert, ids_of_stored)
        data_to_insert = reqData["requestdata"]
        data=tuple(data_to_insert.values())
        sta=dbilayer.insertIntoDBWithoutCondition('dbuac',constants.column_dbuac_table, data)
        if(sta == "Success"):
            respsucc={"responseid": reqData['requestid'], "responsefor": "Create", "responsesetto": reqData['requestsrc'], "response": {"message": "Success"}}
            return respsucc
        else:
            respfail={"responseid": reqData['requestid'], "responsefor": "Create", "responsesetto": reqData['requestsrc'], "response": {"message": "Some Error in Request"}}
            return respfail
    else:
        respfail={"responseid": reqData['requestid'], "responsefor": "Create", "responsesetto": reqData['requestsrc'], "response": {"message": "Error Encountered"}}
        return respfail
    
 #1.5. Delete One Conditional
def dbuac_processdeleteonecond(reqData):
    if reqData['requestdata']['dbuacid']:
        data = reqData['requestdata']['dbuacid']
        sta = dbilayer.updateValuesIndb('dbuac',"status ='9'" ,"dbuacid = {}".format(data))
        print(sta)
        if(sta == "Success"):
            respsucc = {"responseid": reqData['requestid'], "responsefor":"dbacl_processdeleteonecond","responseto":"UI","responsedata": {"message":"Deleted Successfully"}}
            return  respsucc
        elif(sta == 'Failed'):
            respfail = {"responseid": reqData['requestid'], "responsefor":"dbacl_processdeleteonecond","responseto":"UI","responsedata": {"message":"Delete request Failed"}}
            return  respfail
    else:
        respfail = {"responseid": reqData['requestid'], "responsefor":"dbacl_processdeleteonecond","responseto":"UI","responsedata": {"message":"Error in Request"}}
        return  respfail   
    
#1.6. Update One Conditional
def dbuac_processupdateonecond(reqData):
    if isinstance(reqData, dict):
        data = reqData["requestdata"]
        dbuactype = data['dbuactype']
        dbuacid = data['dbuacid']
        dbroleid = data['dbroleid']
        dbuacname = data['dbuacname']
        status = data['status']
        condition = "dbuacid = {}".format(dbuacid)
        updateStatement = "dbuactype = '{}', dbroleid={}, dbuacname = '{}',status = '{}'".format(dbuactype,dbroleid,dbuacname,status)
        sta = dbilayer.updateValuesIndb('dbuac', updateStatement, condition)
        print(sta)
        if(sta == "Success"):
            respsucc = {"responseid": reqData['requestid'], "responsefor":"Update data","responsesetto": reqData['requestsrc'],"responsedata": {"message":"Success"}}
            return  respsucc
        elif(sta == 'Failed'):
            respfail = {"responseid": reqData['requestid'], "responsefor":"Update data","responsesetto": reqData['requestsrc'],"responsedata": {"message":"Failed"}}
            return  respfail
    else:
        respfail = {"responseid": reqData['requestid'], "responsefor":"Update data","responsesetto": reqData['requestsrc'],"responsedata": {"message":"Error in Request"}}
        return  respfail

#1.7. Update All
def dbuac_processupdateall(req):
     pass

## Functions for DBSTATE
# 1.1. Read All without condition
def dbstate_processreadall(reqData):
    if isinstance(reqData, dict):
        if reqData['requestdata']['dbstateid'] == "all":
            sta=dbilayer.readallWithoutCondition('dbstate', '*',tablesdict.dbstate_table)
            #sta=common.list2dict(sta)
            if (len(sta) >= 1):
                respsucc={"responseid": reqData['requestid'], "responsefor": "Read all", "responsesetto": reqData['requestsrc'], "response": {"message": sta}}
                return respsucc
            else:
                respfail={"responseid": reqData['requestid'], "responsefor": "Read all", "responsesetto": reqData['requestsrc'], "response": {"message": "No data Received!"}}
                return respfail
        else:
            respfail={"responseid": reqData['requestid'], "responsefor": "Read all", "responsesetto": reqData['requestsrc'], "response": {"message": "Some error in request"}}
            return respfail    
    else:
        respfail={"responseid": reqData['requestid'], "responsefor": "Read all", "responsesetto": reqData['requestsrc'], "response": {"message": "Some error in request"}}
        return respfail
    
# 1.2. Read Multiple Conditional
def dbstate_processreadmanycond(reqData):
    if isinstance(reqData, dict):
        condition_data=reqData['requestdata']
        condition_data = "status = '{}'".format(condition_data["status"])
        sta=dbilayer.readOneWithcondition('dbstate', '*', condition_data,tablesdict.dbstate_table)
        if (len(sta) >= 1):
            #sta=common.list2dict(sta)
            respsucc={"responseid": reqData['requestid'], "responsefor": "Read all with condition", "responsesetto": reqData['requestsrc'], "response": {"message": sta}}
            return respsucc
        else:
            respfail={"responseid": reqData['requestid'], "responsefor": "Read all with condition", "responsesetto": reqData['requestsrc'], "response":{"message": "No data received!"}}
            return respfail
    else:
        respfail={"responseid": reqData['requestid'], "responsefor": "Read all with condition", "responsesetto": reqData['requestsrc'], "response": {"message": "Error Encountered"}}
        return respfail
    
# 1.3. Read One Conditional
def dbstate_processreadonecond(reqData):
    if isinstance(reqData, dict):
        condition_data=reqData['requestdata']
        condition = "dbstateid = {} AND status = '{}'".format(condition_data["dbstateid"], condition_data["status"])
        sta=dbilayer.readOneWithcondition('dbstate', '*', condition,tablesdict.dbstate_table)
        print(sta)
        #sta=common.list2dict(sta)
        if (len(sta) >= 1):
            respsucc={"responseid": reqData['requestid'], "responsefor": "Read one", "responsesetto": reqData['requestsrc'], "response": {"message": sta}}
            return respsucc
        else:
            respfail={"responseid": reqData['requestid'], "responsefor": "Read one", "responsesetto": reqData['requestsrc'], "response": {"message": "No data Received!"}}
            return respfail
    else:
        respfail={"responseid": reqData['requestid'], "responsefor": "Read one", "responsesetto": reqData['requestsrc'], "response": {"message": "Error Encountered"}}
        return respfail    

# 1.4. Create
def dbstate_processcreate(reqData):
    if isinstance(reqData, dict):
        #data_to_insert, ids_of_stored = generate_unique_ids('pagename','pagelayoutpropid',reqData, 'pagelayoutnprops')
        #print("all stored ids in db", data_to_insert, ids_of_stored)
        data_to_insert = reqData["requestdata"]
        data=tuple(data_to_insert.values())
        sta=dbilayer.insertIntoDBWithoutCondition('dbstate',constants.column_dbstate_table, data)
        if(sta == "Success"):
            respsucc={"responseid": reqData['requestid'], "responsefor": "Create", "responsesetto": reqData['requestsrc'], "response": {"message": "Success"}}
            return respsucc
        else:
            respfail={"responseid": reqData['requestid'], "responsefor": "Create", "responsesetto": reqData['requestsrc'], "response": {"message": "Some Error in Request"}}
            return respfail
    else:
        respfail={"responseid": reqData['requestid'], "responsefor": "Create", "responsesetto": reqData['requestsrc'], "response": {"message": "Error Encountered"}}
        return respfail
    
 #1.5. Delete One Conditional
def dbstate_processdeleteonecond(reqData):
    if reqData['requestdata']['dbstateid']:
        data = reqData['requestdata']['dbstateid']
        sta = dbilayer.updateValuesIndb('dbstate',"status ='9'" ,"dbstateid = {}".format(data))
        print(sta)
        if(sta == "Success"):
            respsucc = {"responseid": reqData['requestid'], "responsefor":"dbacl_processdeleteonecond","responseto":"UI","responsedata": {"message":"Deleted Successfully"}}
            return  respsucc
        elif(sta == 'Failed'):
            respfail = {"responseid": reqData['requestid'], "responsefor":"dbacl_processdeleteonecond","responseto":"UI","responsedata": {"message":"Delete request Failed"}}
            return  respfail
    else:
        respfail = {"responseid": reqData['requestid'], "responsefor":"dbacl_processdeleteonecond","responseto":"UI","responsedata": {"message":"Error in Request"}}
        return  respfail   
    
#1.6. Update One Conditional
def dbstate_processupdateonecond(reqData):
    if isinstance(reqData, dict):
        
        data = reqData["requestdata"]
        dbstatename = data['dbstatename']
        dbstateid = data['dbstateid']
        dbcountryid = data['dbcountryid']
        dbstatedesc = data['dbstatedesc']
        status = data['status']
        condition = "dbstateid = {}".format(dbstateid)
        updateStatement = "dbstatename = '{}', dbcountryid={}, dbstatedesc = '{}',status = '{}'".format(dbstatename,dbcountryid,dbstatedesc,status)
        sta = dbilayer.updateValuesIndb('dbstate', updateStatement, condition)
        print(sta)
        if(sta == "Success"):
            respsucc = {"responseid": reqData['requestid'], "responsefor":"Update data","responsesetto": reqData['requestsrc'],"responsedata": {"message":"Success"}}
            return  respsucc
        elif(sta == 'Failed'):
            respfail = {"responseid": reqData['requestid'], "responsefor":"Update data","responsesetto": reqData['requestsrc'],"responsedata": {"message":"Failed"}}
            return  respfail
    else:
        respfail = {"responseid": reqData['requestid'], "responsefor":"Update data","responsesetto": reqData['requestsrc'],"responsedata": {"message":"Error in Request"}}
        return  respfail

#1.7. Update All
def dbstate_processupdateall(req):
     pass


## Functions for DBdbdelnote
# 1.1. Read All without condition
def dbdelnote_processreadall(reqData):
    if isinstance(reqData, dict):
        if reqData['requestdata']['dbdeletenoteid'] == "all":
            sta=dbilayer.readallWithoutCondition('dbdeletenote', '*',tablesdict.dbdeleteNote_table)
            #sta=common.list2dict(sta)
            if (len(sta) >= 1):
                respsucc={"responseid": reqData['requestid'], "responsefor": "Read all", "responsesetto": reqData['requestsrc'], "response": {"message": sta}}
                return respsucc
            else:
                respfail={"responseid": reqData['requestid'], "responsefor": "Read all", "responsesetto": reqData['requestsrc'], "response": {"message": "No data Received!"}}
                return respfail
        else:
            respfail={"responseid": reqData['requestid'], "responsefor": "Read all", "responsesetto": reqData['requestsrc'], "response": {"message": "Some error in request"}}
            return respfail    
    else:
        respfail={"responseid": reqData['requestid'], "responsefor": "Read all", "responsesetto": reqData['requestsrc'], "response": {"message": "Some error in request"}}
        return respfail
    
# 1.2. Read Multiple Conditional
def dbdelnote_processreadmanycond(reqData):
    if isinstance(reqData, dict):
        condition_data=reqData['requestdata']
        condition_data = "status = '{}'".format(condition_data["status"])
        sta=dbilayer.readOneWithcondition('dbdeletenote', '*', condition_data,tablesdict.dbdeleteNote_table)
        if (len(sta) >= 1):
            #sta=common.list2dict(sta)
            respsucc={"responseid": reqData['requestid'], "responsefor": "Read all with condition", "responsesetto": reqData['requestsrc'], "response": {"message": sta}}
            return respsucc
        else:
            respfail={"responseid": reqData['requestid'], "responsefor": "Read all with condition", "responsesetto": reqData['requestsrc'], "response":{"message": "No data received!"}}
            return respfail
    else:
        respfail={"responseid": reqData['requestid'], "responsefor": "Read all with condition", "responsesetto": reqData['requestsrc'], "response": {"message": "Error Encountered"}}
        return respfail
    
# 1.3. Read One Conditional
def dbdelnote_processreadonecond(reqData):
    if isinstance(reqData, dict):
        condition_data=reqData['requestdata']
        condition = "dbdeletenoteid = {} AND status = '{}'".format(condition_data["dbdeletenoteid"], condition_data["status"])
        sta=dbilayer.readOneWithcondition('dbdeletenote', '*', condition,tablesdict.dbdeleteNote_table)
        print(sta)
        #sta=common.list2dict(sta)
        if (len(sta) >= 1):
            respsucc={"responseid": reqData['requestid'], "responsefor": "Read one", "responsesetto": reqData['requestsrc'], "response": {"message": sta}}
            return respsucc
        else:
            respfail={"responseid": reqData['requestid'], "responsefor": "Read one", "responsesetto": reqData['requestsrc'], "response": {"message": "No data Received!"}}
            return respfail
    else:
        respfail={"responseid": reqData['requestid'], "responsefor": "Read one", "responsesetto": reqData['requestsrc'], "response": {"message": "Error Encountered"}}
        return respfail    

# 1.4. Create
def dbdelnote_processcreate(reqData):
    if isinstance(reqData, dict):
        #data_to_insert, ids_of_stored = generate_unique_ids('pagename','pagelayoutpropid',reqData, 'pagelayoutnprops')
        #print("all stored ids in db", data_to_insert, ids_of_stored)
        data_to_insert = reqData["requestdata"]
        data=tuple(data_to_insert.values())
        sta=dbilayer.insertIntoDBWithoutCondition('dbdeletenote',constants.column_dbdeleteNote_table, data)
        if(sta == "Success"):
            respsucc={"responseid": reqData['requestid'], "responsefor": "Create", "responsesetto": reqData['requestsrc'], "response": {"message": "Success"}}
            return respsucc
        else:
            respfail={"responseid": reqData['requestid'], "responsefor": "Create", "responsesetto": reqData['requestsrc'], "response": {"message": "Some Error in Request"}}
            return respfail
    else:
        respfail={"responseid": reqData['requestid'], "responsefor": "Create", "responsesetto": reqData['requestsrc'], "response": {"message": "Error Encountered"}}
        return respfail
    
 #1.5. Delete One Conditional
def dbdelnote_processdeleteonecond(reqData):
    if reqData['requestdata']['dbdeletenoteid']:
        data = reqData['requestdata']['dbdeletenoteid']
        sta = dbilayer.updateValuesIndb('dbdeletenote',"status ='9'" ,"dbdeletenoteid = {}".format(data))
        print(sta)
        if(sta == "Success"):
            respsucc = {"responseid": reqData['requestid'], "responsefor":"dbdeleteNote_processdeleteonecond","responseto":"UI","responsedata": {"message":"Deleted Successfully"}}
            return  respsucc
        elif(sta == 'Failed'):
            respfail = {"responseid": reqData['requestid'], "responsefor":"dbdeleteNote_processdeleteonecond","responseto":"UI","responsedata": {"message":"Delete request Failed"}}
            return  respfail
    else:
        respfail = {"responseid": reqData['requestid'], "responsefor":"dbdeleteNote_processdeleteonecond","responseto":"UI","responsedata": {"message":"Error in Request"}}
        return  respfail   
    
#1.6. Update One Conditional
def dbdelnote_processupdateonecond(reqData):
    if isinstance(reqData, dict):
        data=reqData['requestdata']
        dbdeletenotename = data['dbdeletenotename']
        dbdeletenoteid = data['dbdeletenoteid']
        dbdeletenotedesc = data['dbdeletenotedesc']
        status = data['status']
        updateStatement = "dbdeletenotename = '{}',dbdeletenotedesc = '{}',status = '{}'".format(dbdeletenotename,dbdeletenotedesc,status)
        condition = "dbdeletenoteid = {}".format(dbdeletenoteid)
        sta = dbilayer.updateValuesIndb('dbdeletenote', updateStatement, condition)
        print(sta)
        if(sta == "Success"):
            respsucc = {"responseid": reqData['requestid'], "responsefor":"Update data","responsesetto": reqData['requestsrc'],"responsedata": {"message":"Success"}}
            return  respsucc
        elif(sta == 'Failed'):
            respfail = {"responseid": reqData['requestid'], "responsefor":"Update data","responsesetto": reqData['requestsrc'],"responsedata": {"message":"Failed"}}
            return  respfail
    else:
        respfail = {"responseid": reqData['requestid'], "responsefor":"Update data","responsesetto": reqData['requestsrc'],"responsedata": {"message":"Error in Request"}}
        return  respfail

#1.7. Update All
def dbdelnote_processupdateall(req):
     pass

## Functions for DBschema
# 1.1. Read All without condition
def dbschema_processreadall(reqData):
    if isinstance(reqData, dict):
        if reqData['requestdata']['dbschemaid'] == "all":
            sta=dbilayer.readallWithoutCondition('dbschema', '*',tablesdict.dbschema_table)
            #sta=common.list2dict(sta)
            if (len(sta) >= 1):
                respsucc={"responseid": reqData['requestid'], "responsefor": "Read all", "responsesetto": reqData['requestsrc'], "response": {"message": sta}}
                return respsucc
            else:
                respfail={"responseid": reqData['requestid'], "responsefor": "Read all", "responsesetto": reqData['requestsrc'], "response": {"message": "No data Received!"}}
                return respfail
        else:
            respfail={"responseid": reqData['requestid'], "responsefor": "Read all", "responsesetto": reqData['requestsrc'], "response": {"message": "Some error in request"}}
            return respfail    
    else:
        respfail={"responseid": reqData['requestid'], "responsefor": "Read all", "responsesetto": reqData['requestsrc'], "response": {"message": "Some error in request"}}
        return respfail
    
# 1.2. Read Multiple Conditional
def dbschema_processreadmanycond(reqData):
    if isinstance(reqData, dict):
        condition_data=reqData['requestdata']
        condition_data = "status = '{}'".format(condition_data["status"])
        sta=dbilayer.readOneWithcondition('dbschema', '*', condition_data,tablesdict.dbschema_table)
        if (len(sta) >= 1):
            #sta=common.list2dict(sta)
            respsucc={"responseid": reqData['requestid'], "responsefor": "Read all with condition", "responsesetto": reqData['requestsrc'], "response": {"message": sta}}
            return respsucc
        else:
            respfail={"responseid": reqData['requestid'], "responsefor": "Read all with condition", "responsesetto": reqData['requestsrc'], "response":{"message": "No data received!"}}
            return respfail
    else:
        respfail={"responseid": reqData['requestid'], "responsefor": "Read all with condition", "responsesetto": reqData['requestsrc'], "response": {"message": "Error Encountered"}}
        return respfail
    
# 1.3. Read One Conditional
def dbschema_processreadonecond(reqData):
    if isinstance(reqData, dict):
        condition_data=reqData['requestdata']
        condition = "dbschemaid = {} AND status = '{}'".format(condition_data["dbschemaid"], condition_data["status"])
        sta=dbilayer.readOneWithcondition('dbschema', '*', condition,tablesdict.dbschema_table)
        print(sta)
        #sta=common.list2dict(sta)
        if (len(sta) >= 1):
            respsucc={"responseid": reqData['requestid'], "responsefor": "Read one", "responsesetto": reqData['requestsrc'], "response": {"message": sta}}
            return respsucc
        else:
            respfail={"responseid": reqData['requestid'], "responsefor": "Read one", "responsesetto": reqData['requestsrc'], "response": {"message": "No data Received!"}}
            return respfail
    else:
        respfail={"responseid": reqData['requestid'], "responsefor": "Read one", "responsesetto": reqData['requestsrc'], "response": {"message": "Error Encountered"}}
        return respfail    

# 1.4. Create
def dbschema_processcreate(reqData):
    if isinstance(reqData, dict):
        #data_to_insert, ids_of_stored = generate_unique_ids('pagename','pagelayoutpropid',reqData, 'pagelayoutnprops')
        #print("all stored ids in db", data_to_insert, ids_of_stored)
        data_to_insert = reqData["requestdata"]
        data=tuple(data_to_insert.values())
        sta=dbilayer.insertIntoDBWithoutCondition('dbschema',constants.column_dbschema_table, data)
        if(sta == "Success"):
            respsucc={"responseid": reqData['requestid'], "responsefor": "Create", "responsesetto": reqData['requestsrc'], "response": {"message": "Success"}}
            return respsucc
        else:
            respfail={"responseid": reqData['requestid'], "responsefor": "Create", "responsesetto": reqData['requestsrc'], "response": {"message": "Some Error in Request"}}
            return respfail
    else:
        respfail={"responseid": reqData['requestid'], "responsefor": "Create", "responsesetto": reqData['requestsrc'], "response": {"message": "Error Encountered"}}
        return respfail
    
 #1.5. Delete One Conditional
def dbschema_processdeleteonecond(reqData):
    if reqData['requestdata']['dbschemaid']:
        data = reqData['requestdata']['dbschemaid']
        sta = dbilayer.updateValuesIndb('dbschema',"status ='9'" ,"dbschemaid = {}".format(data))
        print(sta)
        if(sta == "Success"):
            respsucc = {"responseid": reqData['requestid'], "responsefor":"dbdeleteNote_processdeleteonecond","responseto":"UI","responsedata": {"message":"Deleted Successfully"}}
            return  respsucc
        elif(sta == 'Failed'):
            respfail = {"responseid": reqData['requestid'], "responsefor":"dbdeleteNote_processdeleteonecond","responseto":"UI","responsedata": {"message":"Delete request Failed"}}
            return  respfail
    else:
        respfail = {"responseid": reqData['requestid'], "responsefor":"dbdeleteNote_processdeleteonecond","responseto":"UI","responsedata": {"message":"Error in Request"}}
        return  respfail   
    
#1.6. Update One Conditional
def dbschema_processupdateonecond(reqData):
    if isinstance(reqData, dict):
        data=reqData['requestdata']
        dbschemaname = data['dbschemaname']
        dbschemaid = data['dbschemaid']
        dbschemadesc = data['dbschemadesc']
        dbcollectionid = data['dbcollectionid']
        dbauthid = data['dbauthid']
        dbencodingid = data['dbencodingid']
        dbvariabletypeid = data['dbvariabletypeid']
        status = data['status']
        updateStatement = "dbschemaname = '{}',dbschemadesc = '{}',dbcollectionid = {}, dbauthid = {}, dbencodingid = {}, dbvariabletypeid = {}, status = '{}'".format(dbschemaname,dbschemadesc,dbcollectionid,dbauthid,dbencodingid,dbvariabletypeid,status)
        condition = "dbschemaid = {}".format(dbschemaid)
        sta = dbilayer.updateValuesIndb('dbschema', updateStatement, condition)
        print(sta)
        if(sta == "Success"):
            respsucc = {"responseid": reqData['requestid'], "responsefor":"Update data","responsesetto": reqData['requestsrc'],"responsedata": {"message":"Success"}}
            return  respsucc
        elif(sta == 'Failed'):
            respfail = {"responseid": reqData['requestid'], "responsefor":"Update data","responsesetto": reqData['requestsrc'],"responsedata": {"message":"Failed"}}
            return  respfail
    else:
        respfail = {"responseid": reqData['requestid'], "responsefor":"Update data","responsesetto": reqData['requestsrc'],"responsedata": {"message":"Error in Request"}}
        return  respfail

#1.7. Update All
def dbschema_processupdateall(req):
     pass



# Functions for DBdeploye
# 1.1. Read All without condition
def dbdeploye_processreadmanywithoutcond(reqData):
    if isinstance(reqData, dict):
        if reqData['requestdata']['dbdeployid'] == "all":
            sta=dbilayer.readallWithoutCondition('dbdeploy', '*',tablesdict.dbdeploy_table)
            #sta=common.list2dict(sta)
            if (len(sta) >= 1):
                respsucc={"responseid": reqData['requestid'], "responsefor": "Read all", "responsesetto": reqData['requestsrc'], "response": {"message": sta}}
                return respsucc
            else:
                respfail={"responseid": reqData['requestid'], "responsefor": "Read all", "responsesetto": reqData['requestsrc'], "response": {"message": "No data Received!"}}
                return respfail
        else:
            respfail={"responseid": reqData['requestid'], "responsefor": "Read all", "responsesetto": reqData['requestsrc'], "response": {"message": "Some error in request"}}
            return respfail    
    else:
        respfail={"responseid": reqData['requestid'], "responsefor": "Read all", "responsesetto": reqData['requestsrc'], "response": {"message": "Some error in request"}}
        return respfail
    
# 1.2. Read Multiple Conditional
def dbdeploye_processreadmanycond(reqData):
    if isinstance(reqData, dict):
        condition_data=reqData['requestdata']
        condition_data = "status = '{}'".format(condition_data["status"])
        sta=dbilayer.readOneWithcondition('dbdeploy', '*', condition_data,tablesdict.dbdeploy_table)
        if (len(sta) >= 1):
            #sta=common.list2dict(sta)
            respsucc={"responseid": reqData['requestid'], "responsefor": "Read all with condition", "responsesetto": reqData['requestsrc'], "response": {"message": sta}}
            return respsucc
        else:
            respfail={"responseid": reqData['requestid'], "responsefor": "Read all with condition", "responsesetto": reqData['requestsrc'], "response":{"message": "No data received!"}}
            return respfail
    else:
        respfail={"responseid": reqData['requestid'], "responsefor": "Read all with condition", "responsesetto": reqData['requestsrc'], "response": {"message": "Error Encountered"}}
        return respfail
    
# 1.3. Read One Conditional
def dbdeploye_processreadonecond(reqData):
    if isinstance(reqData, dict):
        condition_data=reqData['requestdata']
        condition = "dbdeployid = {} AND status = '{}'".format(condition_data["dbdeployid"], condition_data["status"])
        sta=dbilayer.readOneWithcondition('dbdeploy', '*', condition,tablesdict.dbdeploy_table)
        print(sta)
        #sta=common.list2dict(sta)
        if (len(sta) >= 1):
            respsucc={"responseid": reqData['requestid'], "responsefor": "Read one", "responsesetto": reqData['requestsrc'], "response": {"message": sta}}
            return respsucc
        else:
            respfail={"responseid": reqData['requestid'], "responsefor": "Read one", "responsesetto": reqData['requestsrc'], "response": {"message": "No data Received!"}}
            return respfail
    else:
        respfail={"responseid": reqData['requestid'], "responsefor": "Read one", "responsesetto": reqData['requestsrc'], "response": {"message": "Error Encountered"}}
        return respfail    

# 1.4. Create
def dbdeploye_processcreate(reqData):
    if isinstance(reqData, dict):
        #data_to_insert, ids_of_stored = generate_unique_ids('pagename','pagelayoutpropid',reqData, 'pagelayoutnprops')
        #print("all stored ids in db", data_to_insert, ids_of_stored)
        data_to_insert = reqData["requestdata"]
        data=tuple(data_to_insert.values())
        sta=dbilayer.insertIntoDBWithoutCondition('dbdeploy',constants.column_dbdeploy_table, data)
        if(sta == "Success"):
            respsucc={"responseid": reqData['requestid'], "responsefor": "Create", "responsesetto": reqData['requestsrc'], "response": {"message": "Success"}}
            return respsucc
        else:
            respfail={"responseid": reqData['requestid'], "responsefor": "Create", "responsesetto": reqData['requestsrc'], "response": {"message": "Some Error in Request"}}
            return respfail
    else:
        respfail={"responseid": reqData['requestid'], "responsefor": "Create", "responsesetto": reqData['requestsrc'], "response": {"message": "Error Encountered"}}
        return respfail
    
 #1.5. Delete One Conditional
def dbdeploye_processdeleteonecond(reqData):
    if reqData['requestdata']['dbdeployid']:
        data = reqData['requestdata']['dbdeployid']
        sta = dbilayer.updateValuesIndb('dbdeploy',"status ='9'" ,"dbdeployid = {}".format(data))
        print(sta)
        if(sta == "Success"):
            respsucc = {"responseid": reqData['requestid'], "responsefor":"dbDeploy_processdeleteonecond","responseto":"UI","responsedata": {"message":"Deleted Successfully"}}
            return  respsucc
        elif(sta == 'Failed'):
            respfail = {"responseid": reqData['requestid'], "responsefor":"dbDeploy_processdeleteonecond","responseto":"UI","responsedata": {"message":"Delete request Failed"}}
            return  respfail
    else:
        respfail = {"responseid": reqData['requestid'], "responsefor":"dbDeploy_processdeleteonecond","responseto":"UI","responsedata": {"message":"Error in Request"}}
        return  respfail   
    
#1.6. Update One Conditional
def dbdeploye_processupdateonecond(reqData):
    if isinstance(reqData, dict):
        data=reqData['requestdata']
        dbdeployname = data['dbdeployname']
        dbdeployid = data['dbdeployid']
        dbbillingid = data['dbbillingid']
        status = data['status']
        updateStatement = "dbdeployname = '{}',dbbillingid = {},status = '{}'".format(dbdeployname,dbbillingid,status)
        condition = "dbdeployid = {}".format(dbdeployid)
        sta = dbilayer.updateValuesIndb('dbdeploy', updateStatement, condition)
        print(sta)
        if(sta == "Success"):
            respsucc = {"responseid": reqData['requestid'], "responsefor":"Update data","responsesetto": reqData['requestsrc'],"responsedata": {"message":"Success"}}
            return  respsucc
        elif(sta == 'Failed'):
            respfail = {"responseid": reqData['requestid'], "responsefor":"Update data","responsesetto": reqData['requestsrc'],"responsedata": {"message":"Failed"}}
            return  respfail
    else:
        respfail = {"responseid": reqData['requestid'], "responsefor":"Update data","responsesetto": reqData['requestsrc'],"responsedata": {"message":"Error in Request"}}
        return  respfail

#1.7. Update All
def dbdeploye_processupdateall(req):
     pass



## Functions for DBEmail
# 1.1. Create
def dbemail_processcreate(reqData):
    if isinstance(reqData, dict):
        #data_to_insert, ids_of_stored = generate_unique_ids('pagename','pagelayoutpropid',reqData, 'pagelayoutnprops')
        #print("all stored ids in db", data_to_insert, ids_of_stored)
        data_to_insert = reqData["requestdata"]
        data=tuple(data_to_insert.values())
        sta=dbilayer.insertIntoDBWithoutCondition('dbemail',constants.column_dbemail_table, data)
        if(sta == "Success"):
            respsucc={"responseid": reqData['requestid'], "responsefor": "Create", "responsesetto": reqData['requestsrc'], "response": {"message": "Success"}}
            return respsucc
        else:
            respfail={"responseid": reqData['requestid'], "responsefor": "Create", "responsesetto": reqData['requestsrc'], "response": {"message": "Some Error in Request"}}
            return respfail
    else:
        respfail={"responseid": reqData['requestid'], "responsefor": "Create", "responsesetto": reqData['requestsrc'], "response": {"message": "Error Encountered"}}
        return respfail


# 1.2. Read One Conditional
def dbemail_processreadonecond(reqData):
    if isinstance(reqData, dict):
        condition_data=reqData['requestdata']
        condition = "dbemailid = {} AND status = '{}'".format(condition_data["dbemailid"], condition_data["status"])
        sta=dbilayer.readOneWithcondition('dbemail', '*', condition,tablesdict.dbemail_table)
        print(sta)
        #sta=common.list2dict(sta)
        if (len(sta) >= 1):
            respsucc={"responseid": reqData['requestid'], "responsefor": "Read one", "responsesetto": reqData['requestsrc'], "response": {"message": sta}}
            return respsucc
        else:
            respfail={"responseid": reqData['requestid'], "responsefor": "Read one", "responsesetto": reqData['requestsrc'], "response": {"message": "No data Received!"}}
            return respfail
    else:
        respfail={"responseid": reqData['requestid'], "responsefor": "Read one", "responsesetto": reqData['requestsrc'], "response": {"message": "Error Encountered"}}
        return respfail    


# 1.3. Read Multiple Conditional
def dbemail_processreadmanycond(reqData):
    if isinstance(reqData, dict):
        condition_data=reqData['requestdata']
        condition_data = "status = '{}'".format(condition_data["status"])
        sta=dbilayer.readOneWithcondition('dbemail', '*', condition_data,tablesdict.dbemail_table)
        if (len(sta) >= 1):
            #sta=common.list2dict(sta)
            respsucc={"responseid": reqData['requestid'], "responsefor": "Read all with condition", "responsesetto": reqData['requestsrc'], "response": {"message": sta}}
            return respsucc
        else:
            respfail={"responseid": reqData['requestid'], "responsefor": "Read all with condition", "responsesetto": reqData['requestsrc'], "response":{"message": "No data received!"}}
            return respfail
    else:
        respfail={"responseid": reqData['requestid'], "responsefor": "Read all with condition", "responsesetto": reqData['requestsrc'], "response": {"message": "Error Encountered"}}
        return respfail
    

# 1.4. Read All without condition
def dbemail_processreadmanywithoutcond(reqData):
    if isinstance(reqData, dict):
        if reqData['requestdata']['dbemailid'] == "all":
            sta=dbilayer.readallWithoutCondition('dbemail', '*',tablesdict.dbemail_table)
            #sta=common.list2dict(sta)
            if (len(sta) >= 1):
                respsucc={"responseid": reqData['requestid'], "responsefor": "Read all", "responsesetto": reqData['requestsrc'], "response": {"message": sta}}
                return respsucc
            else:
                respfail={"responseid": reqData['requestid'], "responsefor": "Read all", "responsesetto": reqData['requestsrc'], "response": {"message": "No data Received!"}}
                return respfail
        else:
            respfail={"responseid": reqData['requestid'], "responsefor": "Read all", "responsesetto": reqData['requestsrc'], "response": {"message": "Some error in request"}}
            return respfail    
    else:
        respfail={"responseid": reqData['requestid'], "responsefor": "Read all", "responsesetto": reqData['requestsrc'], "response": {"message": "Some error in request"}}
        return respfail
    
 #1.5. Delete One Conditional
def dbemail_processdeleteonecond(reqData):
    if reqData['requestdata']['dbemailid']:
        data = reqData['requestdata']['dbemailid']
        sta = dbilayer.updateValuesIndb('dbemail',"status ='9'" ,"dbemailid = {}".format(data))
        print(sta)
        if(sta == "Success"):
            respsucc = {"responseid": reqData['requestid'], "responsefor":"dbEmail_processdeleteonecond","responseto":"UI","responsedata": {"message":"Deleted Successfully"}}
            return  respsucc
        elif(sta == 'Failed'):
            respfail = {"responseid": reqData['requestid'], "responsefor":"dbEmail_processdeleteonecond","responseto":"UI","responsedata": {"message":"Delete request Failed"}}
            return  respfail
    else:
        respfail = {"responseid": reqData['requestid'], "responsefor":"dbEmail_processdeleteonecond","responseto":"UI","responsedata": {"message":"Error in Request"}}
        return  respfail   
    
#1.6. Update One Conditional
def dbemail_processupdateonecond(reqData):
    if isinstance(reqData, dict):
        data=reqData['requestdata']
        dbemail = data['dbemail']
        dbemailid = data['dbemailid']
        status = data['status']
        updateStatement = "dbemail = '{}',status = '{}'".format(dbemail,status)
        condition = "dbemailid = {}".format(dbemailid)
        sta = dbilayer.updateValuesIndb('dbemail', updateStatement, condition)
        print(sta)
        if(sta == "Success"):
            respsucc = {"responseid": reqData['requestid'], "responsefor":"Update data","responsesetto": reqData['requestsrc'],"responsedata": {"message":"Success"}}
            return  respsucc
        elif(sta == 'Failed'):
            respfail = {"responseid": reqData['requestid'], "responsefor":"Update data","responsesetto": reqData['requestsrc'],"responsedata": {"message":"Failed"}}
            return  respfail
    else:
        respfail = {"responseid": reqData['requestid'], "responsefor":"Update data","responsesetto": reqData['requestsrc'],"responsedata": {"message":"Error in Request"}}
        return  respfail

#1.7. Update All
def dbemail_processupdateall(req):
     pass



## Functions for DBEncoding
# 1.1. Create
def dbencoding_processcreate(reqData):
    if isinstance(reqData, dict):
        #data_to_insert, ids_of_stored = generate_unique_ids('pagename','pagelayoutpropid',reqData, 'pagelayoutnprops')
        #print("all stored ids in db", data_to_insert, ids_of_stored)
        data_to_insert = reqData["requestdata"]
        data=tuple(data_to_insert.values())
        sta=dbilayer.insertIntoDBWithoutCondition('dbencoding',constants.column_dbencoding_table, data)
        if(sta == "Success"):
            respsucc={"responseid": reqData['requestid'], "responsefor": "Create", "responsesetto": reqData['requestsrc'], "response": {"message": "Success"}}
            return respsucc
        else:
            respfail={"responseid": reqData['requestid'], "responsefor": "Create", "responsesetto": reqData['requestsrc'], "response": {"message": "Some Error in Request"}}
            return respfail
    else:
        respfail={"responseid": reqData['requestid'], "responsefor": "Create", "responsesetto": reqData['requestsrc'], "response": {"message": "Error Encountered"}}
        return respfail


# 1.2. Read One Conditional
def dbencoding_processreadonecond(reqData):
    if isinstance(reqData, dict):
        condition_data=reqData['requestdata']
        condition = "dbencodingid = {} AND status = '{}'".format(condition_data["dbencodingid"], condition_data["status"])
        sta=dbilayer.readOneWithcondition('dbencoding', '*', condition, tablesdict.dbencoding_table)
        print(sta)
        #sta=common.list2dict(sta)
        if (len(sta) >= 1):
            respsucc={"responseid": reqData['requestid'], "responsefor": "Read one", "responsesetto": reqData['requestsrc'], "response": {"message": sta}}
            return respsucc
        else:
            respfail={"responseid": reqData['requestid'], "responsefor": "Read one", "responsesetto": reqData['requestsrc'], "response": {"message": "No data Received!"}}
            return respfail
    else:
        respfail={"responseid": reqData['requestid'], "responsefor": "Read one", "responsesetto": reqData['requestsrc'], "response": {"message": "Error Encountered"}}
        return respfail    


# 1.3. Read Multiple Conditional
def dbencoding_processreadmanycond(reqData):
    if isinstance(reqData, dict):
        condition_data=reqData['requestdata']
        condition_data = "status = '{}'".format(condition_data["status"])
        sta=dbilayer.readOneWithcondition('dbencoding', '*', condition_data,tablesdict.dbencoding_table)
        if (len(sta) >= 1):
            #sta=common.list2dict(sta)
            respsucc={"responseid": reqData['requestid'], "responsefor": "Read all with condition", "responsesetto": reqData['requestsrc'], "response": {"message": sta}}
            return respsucc
        else:
            respfail={"responseid": reqData['requestid'], "responsefor": "Read all with condition", "responsesetto": reqData['requestsrc'], "response":{"message": "No data received!"}}
            return respfail
    else:
        respfail={"responseid": reqData['requestid'], "responsefor": "Read all with condition", "responsesetto": reqData['requestsrc'], "response": {"message": "Error Encountered"}}
        return respfail
    

# 1.4. Read All without condition
def dbencoding_processreadmanywithoutcond(reqData):
    if isinstance(reqData, dict):
        if reqData['requestdata']['dbencodingid'] == "all":
            sta=dbilayer.readallWithoutCondition('dbencoding', '*',tablesdict.dbencoding_table)
            #sta=common.list2dict(sta)
            if (len(sta) >= 1):
                respsucc={"responseid": reqData['requestid'], "responsefor": "Read all", "responsesetto": reqData['requestsrc'], "response": {"message": sta}}
                return respsucc
            else:
                respfail={"responseid": reqData['requestid'], "responsefor": "Read all", "responsesetto": reqData['requestsrc'], "response": {"message": "No data Received!"}}
                return respfail
        else:
            respfail={"responseid": reqData['requestid'], "responsefor": "Read all", "responsesetto": reqData['requestsrc'], "response": {"message": "Some error in request"}}
            return respfail    
    else:
        respfail={"responseid": reqData['requestid'], "responsefor": "Read all", "responsesetto": reqData['requestsrc'], "response": {"message": "Some error in request"}}
        return respfail
    
 #1.5. Delete One Conditional
def dbencoding_processdeleteonecond(reqData):
    if reqData['requestdata']['dbencodingid']:
        data = reqData['requestdata']['dbencodingid']
        sta = dbilayer.updateValuesIndb('dbencoding',"status ='9'" ,"dbencodingid = {}".format(data))
        print(sta)
        if(sta == "Success"):
            respsucc = {"responseid": reqData['requestid'], "responsefor":"dbEncoding_processdeleteonecond","responseto":"UI","responsedata": {"message":"Deleted Successfully"}}
            return  respsucc
        elif(sta == 'Failed'):
            respfail = {"responseid": reqData['requestid'], "responsefor":"dbEncoding_processdeleteonecond","responseto":"UI","responsedata": {"message":"Delete request Failed"}}
            return  respfail
    else:
        respfail = {"responseid": reqData['requestid'], "responsefor":"dbEncoding_processdeleteonecond","responseto":"UI","responsedata": {"message":"Error in Request"}}
        return  respfail   
    
#1.6. Update One Conditional
def dbencoding_processupdateonecond(reqData):
    if isinstance(reqData, dict):
        data=reqData['requestdata']
        dbencodingdesc = data['dbencodingdesc']
        dbencodingid=data['dbencodingid']
        dbencodingname = data['dbencodingname']
        status = data['status']
        updateStatement = "dbencodingdesc = '{}',dbencodingname = '{}',status = '{}'".format(dbencodingdesc, dbencodingname,status)
        condition = "dbencodingid = {}".format(dbencodingid)
        sta = dbilayer.updateValuesIndb('dbencoding', updateStatement, condition)
        print(sta)
        if(sta == "Success"):
            respsucc = {"responseid": reqData['requestid'], "responsefor":"Update data","responsesetto": reqData['requestsrc'],"responsedata": {"message":"Success"}}
            return  respsucc
        elif(sta == 'Failed'):
            respfail = {"responseid": reqData['requestid'], "responsefor":"Update data","responsesetto": reqData['requestsrc'],"responsedata": {"message":"Failed"}}
            return  respfail
    else:
        respfail = {"responseid": reqData['requestid'], "responsefor":"Update data","responsesetto": reqData['requestsrc'],"responsedata": {"message":"Error in Request"}}
        return  respfail

#1.7. Update All
def dbencoding_processupdateall(req):
     pass


## Functions for DBGenInvoice
# 1.1. Create
def dbgeninv_processcreate(reqData):
    if isinstance(reqData, dict):
        #data_to_insert, ids_of_stored = generate_unique_ids('pagename','pagelayoutpropid',reqData, 'pagelayoutnprops')
        #print("all stored ids in db", data_to_insert, ids_of_stored)
        data_to_insert = reqData["requestdata"]
        data=tuple(data_to_insert.values())
        sta=dbilayer.insertIntoDBWithoutCondition('dbgeninvoice',constants.column_dbGenInvoice_table, data)
        if(sta == "Success"):
            respsucc={"responseid": reqData['requestid'], "responsefor": "Create", "responsesetto": reqData['requestsrc'], "response": {"message": "Success"}}
            return respsucc
        else:
            respfail={"responseid": reqData['requestid'], "responsefor": "Create", "responsesetto": reqData['requestsrc'], "response": {"message": "Some Error in Request"}}
            return respfail
    else:
        respfail={"responseid": reqData['requestid'], "responsefor": "Create", "responsesetto": reqData['requestsrc'], "response": {"message": "Error Encountered"}}
        return respfail


# 1.2. Read One Conditional
def dbgeninv_processreadonecond(reqData):
    if isinstance(reqData, dict):
        condition_data=reqData['requestdata']
        condition = "dbgeninvoiceid = {} AND status = '{}'".format(condition_data["dbgeninvoiceid"], condition_data["status"])
        sta=dbilayer.readOneWithcondition('dbgeninvoice', '*', condition,tablesdict.dbGenInvoice_table)
        print(sta)
        #sta=common.list2dict(sta)
        if (len(sta) >= 1):
            respsucc={"responseid": reqData['requestid'], "responsefor": "Read one", "responsesetto": reqData['requestsrc'], "response": {"message": sta}}
            return respsucc
        else:
            respfail={"responseid": reqData['requestid'], "responsefor": "Read one", "responsesetto": reqData['requestsrc'], "response": {"message": "No data Received!"}}
            return respfail
    else:
        respfail={"responseid": reqData['requestid'], "responsefor": "Read one", "responsesetto": reqData['requestsrc'], "response": {"message": "Error Encountered"}}
        return respfail    


# 1.3. Read Multiple Conditional
def dbgeninv_processreadmanycond(reqData):
    if isinstance(reqData, dict):
        condition_data=reqData['requestdata']
        condition_data = "status = '{}'".format(condition_data["status"])
        sta=dbilayer.readOneWithcondition('dbgeninvoice', '*', condition_data,tablesdict.dbGenInvoice_table)
        if (len(sta) >= 1):
            #sta=common.list2dict(sta)
            respsucc={"responseid": reqData['requestid'], "responsefor": "Read all with condition", "responsesetto": reqData['requestsrc'], "response": {"message": sta}}
            return respsucc
        else:
            respfail={"responseid": reqData['requestid'], "responsefor": "Read all with condition", "responsesetto": reqData['requestsrc'], "response":{"message": "No data received!"}}
            return respfail
    else:
        respfail={"responseid": reqData['requestid'], "responsefor": "Read all with condition", "responsesetto": reqData['requestsrc'], "response": {"message": "Error Encountered"}}
        return respfail
    

# 1.4. Read All without condition
def dbgeninv_processreadmanywithoutcond(reqData):
    if isinstance(reqData, dict):
        if reqData['requestdata']['dbgeninvoiceid'] == "all":
            sta=dbilayer.readallWithoutCondition('dbgeninvoice', '*',tablesdict.dbGenInvoice_table)
            #sta=common.list2dict(sta)
            if (len(sta) >= 1):
                respsucc={"responseid": reqData['requestid'], "responsefor": "Read all", "responsesetto": reqData['requestsrc'], "response": {"message": sta}}
                return respsucc
            else:
                respfail={"responseid": reqData['requestid'], "responsefor": "Read all", "responsesetto": reqData['requestsrc'], "response": {"message": "No data Received!"}}
                return respfail
        else:
            respfail={"responseid": reqData['requestid'], "responsefor": "Read all", "responsesetto": reqData['requestsrc'], "response": {"message": "Some error in request"}}
            return respfail    
    else:
        respfail={"responseid": reqData['requestid'], "responsefor": "Read all", "responsesetto": reqData['requestsrc'], "response": {"message": "Some error in request"}}
        return respfail
    
 #1.5. Delete One Conditional
def dbgeninv_processdeleteonecond(reqData):
    if reqData['requestdata']['dbgeninvoiceid']:
        data = reqData['requestdata']['dbgeninvoiceid']
        sta = dbilayer.updateValuesIndb('dbgeninvoice',"status ='9'" ,"dbgeninvoiceid = {}".format(data))
        print(sta)
        if(sta == "Success"):
            respsucc = {"responseid": reqData['requestid'], "responsefor":"dbGenInvoice_processdeleteonecond","responseto":"UI","responsedata": {"message":"Deleted Successfully"}}
            return  respsucc
        elif(sta == 'Failed'):
            respfail = {"responseid": reqData['requestid'], "responsefor":"dbGenInvoice_processdeleteonecond","responseto":"UI","responsedata": {"message":"Delete request Failed"}}
            return  respfail
    else:
        respfail = {"responseid": reqData['requestid'], "responsefor":"dbGenInvoice_processdeleteonecond","responseto":"UI","responsedata": {"message":"Error in Request"}}
        return  respfail   
    
#1.6. Update One Conditional
def dbgeninv_processupdateonecond(reqData):
    if isinstance(reqData, dict):
        data=reqData['requestdata']
        dbgeninvoiceid = data['dbgeninvoiceid']
        dbgeninvoicetype=data['dbgeninvoicetype']
        dbinvoiceid = data['dbinvoiceid']
        status = data['status']
        updateStatement = "dbgeninvoicetype = '{}',dbinvoiceid = {},status = '{}'".format(dbgeninvoicetype, dbinvoiceid,status)
        condition = "dbgeninvoiceid = {}".format(dbgeninvoiceid)
        sta = dbilayer.updateValuesIndb('dbgeninvoice', updateStatement, condition)
        print(sta)
        if(sta == "Success"):
            respsucc = {"responseid": reqData['requestid'], "responsefor":"Update data","responsesetto": reqData['requestsrc'],"responsedata": {"message":"Success"}}
            return  respsucc
        elif(sta == 'Failed'):
            respfail = {"responseid": reqData['requestid'], "responsefor":"Update data","responsesetto": reqData['requestsrc'],"responsedata": {"message":"Failed"}}
            return  respfail
    else:
        respfail = {"responseid": reqData['requestid'], "responsefor":"Update data","responsesetto": reqData['requestsrc'],"responsedata": {"message":"Error in Request"}}
        return  respfail

#1.7. Update All
def dbgeninv_processupdateall(req):
     pass



## Functions for DBGST
# 1.1. Create
def dbgst_processcreate(reqData):
    if isinstance(reqData, dict):
        #data_to_insert, ids_of_stored = generate_unique_ids('pagename','pagelayoutpropid',reqData, 'pagelayoutnprops')
        #print("all stored ids in db", data_to_insert, ids_of_stored)
        data_to_insert = reqData["requestdata"]
        data=tuple(data_to_insert.values())
        sta=dbilayer.insertIntoDBWithoutCondition('dbgst',constants.column_dbgst_table, data)
        if(sta == "Success"):
            respsucc={"responseid": reqData['requestid'], "responsefor": "Create", "responsesetto": reqData['requestsrc'], "response": {"message": "Success"}}
            return respsucc
        else:
            respfail={"responseid": reqData['requestid'], "responsefor": "Create", "responsesetto": reqData['requestsrc'], "response": {"message": "Some Error in Request"}}
            return respfail
    else:
        respfail={"responseid": reqData['requestid'], "responsefor": "Create", "responsesetto": reqData['requestsrc'], "response": {"message": "Error Encountered"}}
        return respfail


# 1.2. Read One Conditional
def dbgst_processreadonecond(reqData):
    if isinstance(reqData, dict):
        condition_data=reqData['requestdata']
        condition = "dbgstid = {} AND status = '{}'".format(condition_data["dbgstid"], condition_data["status"])
        sta=dbilayer.readOneWithcondition('dbgst', '*', condition,tablesdict.dbgst_table)
        print(sta)
        #sta=common.list2dict(sta)
        if (len(sta) >= 1):
            respsucc={"responseid": reqData['requestid'], "responsefor": "Read one", "responsesetto": reqData['requestsrc'], "response": {"message": sta}}
            return respsucc
        else:
            respfail={"responseid": reqData['requestid'], "responsefor": "Read one", "responsesetto": reqData['requestsrc'], "response": {"message": "No data Received!"}}
            return respfail
    else:
        respfail={"responseid": reqData['requestid'], "responsefor": "Read one", "responsesetto": reqData['requestsrc'], "response": {"message": "Error Encountered"}}
        return respfail    


# 1.3. Read Multiple Conditional
def dbgst_processreadmanycond(reqData):
    if isinstance(reqData, dict):
        condition_data=reqData['requestdata']
        condition_data = "status = '{}'".format(condition_data["status"])
        sta=dbilayer.readOneWithcondition('dbgst', '*', condition_data,tablesdict.dbgst_table)
        if (len(sta) >= 1):
            #sta=common.list2dict(sta)
            respsucc={"responseid": reqData['requestid'], "responsefor": "Read all with condition", "responsesetto": reqData['requestsrc'], "response": {"message": sta}}
            return respsucc
        else:
            respfail={"responseid": reqData['requestid'], "responsefor": "Read all with condition", "responsesetto": reqData['requestsrc'], "response":{"message": "No data received!"}}
            return respfail
    else:
        respfail={"responseid": reqData['requestid'], "responsefor": "Read all with condition", "responsesetto": reqData['requestsrc'], "response": {"message": "Error Encountered"}}
        return respfail
    

# 1.4. Read All without condition
def dbgst_processreadmanywithoutcond(reqData):
    if isinstance(reqData, dict):
        if reqData['requestdata']['dbgstid'] == "all":
            sta=dbilayer.readallWithoutCondition('dbgst', '*',tablesdict.dbgst_table)
            #sta=common.list2dict(sta)
            if (len(sta) >= 1):
                respsucc={"responseid": reqData['requestid'], "responsefor": "Read all", "responsesetto": reqData['requestsrc'], "response": {"message": sta}}
                return respsucc
            else:
                respfail={"responseid": reqData['requestid'], "responsefor": "Read all", "responsesetto": reqData['requestsrc'], "response": {"message": "No data Received!"}}
                return respfail
        else:
            respfail={"responseid": reqData['requestid'], "responsefor": "Read all", "responsesetto": reqData['requestsrc'], "response": {"message": "Some error in request"}}
            return respfail    
    else:
        respfail={"responseid": reqData['requestid'], "responsefor": "Read all", "responsesetto": reqData['requestsrc'], "response": {"message": "Some error in request"}}
        return respfail
    
 #1.5. Delete One Conditional
def dbgst_processdeleteonecond(reqData):
    if reqData['requestdata']['dbgstid']:
        data = reqData['requestdata']['dbgstid']
        sta = dbilayer.updateValuesIndb('dbgst',"status ='9'" ,"dbgstid = {}".format(data))
        print(sta)
        if(sta == "Success"):
            respsucc = {"responseid": reqData['requestid'], "responsefor":"dbGST_processdeleteonecond","responseto":"UI","responsedata": {"message":"Deleted Successfully"}}
            return  respsucc
        elif(sta == 'Failed'):
            respfail = {"responseid": reqData['requestid'], "responsefor":"dbGST_processdeleteonecond","responseto":"UI","responsedata": {"message":"Delete request Failed"}}
            return  respfail
    else:
        respfail = {"responseid": reqData['requestid'], "responsefor":"dbGST_processdeleteonecond","responseto":"UI","responsedata": {"message":"Error in Request"}}
        return  respfail   
    
#1.6. Update One Conditional
def dbgst_processupdateonecond(reqData):
    if isinstance(reqData, dict):
        data=reqData['requestdata']
        dbgstnumber = data['dbgstnumber']
        dbgstid=data['dbgstid']
        status = data['status']
        updateStatement = "dbgstnumber = '{}',status = '{}'".format(dbgstnumber,status)
        condition = "dbgstid = {}".format(dbgstid)
        sta = dbilayer.updateValuesIndb('dbgst', updateStatement, condition)
        print(sta)
        if(sta == "Success"):
            respsucc = {"responseid": reqData['requestid'], "responsefor":"Update data","responsesetto": reqData['requestsrc'],"responsedata": {"message":"Success"}}
            return  respsucc
        elif(sta == 'Failed'):
            respfail = {"responseid": reqData['requestid'], "responsefor":"Update data","responsesetto": reqData['requestsrc'],"responsedata": {"message":"Failed"}}
            return  respfail
    else:
        respfail = {"responseid": reqData['requestid'], "responsefor":"Update data","responsesetto": reqData['requestsrc'],"responsedata": {"message":"Error in Request"}}
        return  respfail

#1.7. Update All
def dbgst_processupdateall(req):
     pass



## Functions for DBHash
# 1.1. Create
def dbhash_processcreate(reqData):
    if isinstance(reqData, dict):
        #data_to_insert, ids_of_stored = generate_unique_ids('pagename','pagelayoutpropid',reqData, 'pagelayoutnprops')
        #print("all stored ids in db", data_to_insert, ids_of_stored)
        data_to_insert = reqData["requestdata"]
        data=tuple(data_to_insert.values())
        sta=dbilayer.insertIntoDBWithoutCondition('dbhash',constants.column_dbhash_table, data)
        if(sta == "Success"):
            respsucc={"responseid": reqData['requestid'], "responsefor": "Create", "responsesetto": reqData['requestsrc'], "response": {"message": "Success"}}
            return respsucc
        else:
            respfail={"responseid": reqData['requestid'], "responsefor": "Create", "responsesetto": reqData['requestsrc'], "response": {"message": "Some Error in Request"}}
            return respfail
    else:
        respfail={"responseid": reqData['requestid'], "responsefor": "Create", "responsesetto": reqData['requestsrc'], "response": {"message": "Error Encountered"}}
        return respfail


# 1.2. Read One Conditional
def dbhash_processreadonecond(reqData):
    if isinstance(reqData, dict):
        condition_data=reqData['requestdata']
        condition = "dbhashid = {} AND status = '{}'".format(condition_data["dbhashid"], condition_data["status"])
        sta=dbilayer.readOneWithcondition('dbhash', '*', condition,tablesdict.dbhash_table)
        print(sta)
        #sta=common.list2dict(sta)
        if (len(sta) >= 1):
            respsucc={"responseid": reqData['requestid'], "responsefor": "Read one", "responsesetto": reqData['requestsrc'], "response": {"message": sta}}
            return respsucc
        else:
            respfail={"responseid": reqData['requestid'], "responsefor": "Read one", "responsesetto": reqData['requestsrc'], "response": {"message": "No data Received!"}}
            return respfail
    else:
        respfail={"responseid": reqData['requestid'], "responsefor": "Read one", "responsesetto": reqData['requestsrc'], "response": {"message": "Error Encountered"}}
        return respfail    


# 1.3. Read Multiple Conditional
def dbhash_processreadmanycond(reqData):
    if isinstance(reqData, dict):
        condition_data=reqData['requestdata']
        condition_data = "status = '{}'".format(condition_data["status"])
        sta=dbilayer.readOneWithcondition('dbhash', '*', condition_data,tablesdict.dbhash_table)
        if (len(sta) >= 1):
            #sta=common.list2dict(sta)
            respsucc={"responseid": reqData['requestid'], "responsefor": "Read all with condition", "responsesetto": reqData['requestsrc'], "response": {"message": sta}}
            return respsucc
        else:
            respfail={"responseid": reqData['requestid'], "responsefor": "Read all with condition", "responsesetto": reqData['requestsrc'], "response":{"message": "No data received!"}}
            return respfail
    else:
        respfail={"responseid": reqData['requestid'], "responsefor": "Read all with condition", "responsesetto": reqData['requestsrc'], "response": {"message": "Error Encountered"}}
        return respfail
    

# 1.4. Read All without condition
def dbhash_processreadmanywithoutcond(reqData):
    if isinstance(reqData, dict):
        if reqData['requestdata']['dbhashid'] == "all":
            sta=dbilayer.readallWithoutCondition('dbhash', '*',tablesdict.dbhash_table)
            #sta=common.list2dict(sta)
            if (len(sta) >= 1):
                respsucc={"responseid": reqData['requestid'], "responsefor": "Read all", "responsesetto": reqData['requestsrc'], "response": {"message": sta}}
                return respsucc
            else:
                respfail={"responseid": reqData['requestid'], "responsefor": "Read all", "responsesetto": reqData['requestsrc'], "response": {"message": "No data Received!"}}
                return respfail
        else:
            respfail={"responseid": reqData['requestid'], "responsefor": "Read all", "responsesetto": reqData['requestsrc'], "response": {"message": "Some error in request"}}
            return respfail    
    else:
        respfail={"responseid": reqData['requestid'], "responsefor": "Read all", "responsesetto": reqData['requestsrc'], "response": {"message": "Some error in request"}}
        return respfail
    
 #1.5. Delete One Conditional
def dbhash_processdeleteonecond(reqData):
    if reqData['requestdata']['dbhashid']:
        data = reqData['requestdata']['dbhashid']
        sta = dbilayer.updateValuesIndb('dbhash',"status ='9'" ,"dbhashid = {}".format(data))
        print(sta)
        if(sta == "Success"):
            respsucc = {"responseid": reqData['requestid'], "responsefor":"dbHash_processdeleteonecond","responseto":"UI","responsedata": {"message":"Deleted Successfully"}}
            return  respsucc
        elif(sta == 'Failed'):
            respfail = {"responseid": reqData['requestid'], "responsefor":"dbHash_processdeleteonecond","responseto":"UI","responsedata": {"message":"Delete request Failed"}}
            return  respfail
    else:
        respfail = {"responseid": reqData['requestid'], "responsefor":"dbHash_processdeleteonecond","responseto":"UI","responsedata": {"message":"Error in Request"}}
        return  respfail   
    
#1.6. Update One Conditional
def dbhash_processupdateonecond(reqData):
    if isinstance(reqData, dict):
        data=reqData['requestdata']
        dbhashname = data['dbhashname']
        dbhashid=data['dbhashid']
        dbhashtype=data['dbhashtype']
        status = data['status']
        updateStatement = "dbhashname = '{}',dbhashtype = '{}',status = '{}'".format(dbhashname,dbhashtype,status)
        condition = "dbhashid = {}".format(dbhashid)
        sta = dbilayer.updateValuesIndb('dbhash', updateStatement, condition)
        print(sta)
        if(sta == "Success"):
            respsucc = {"responseid": reqData['requestid'], "responsefor":"Update data","responsesetto": reqData['requestsrc'],"responsedata": {"message":"Success"}}
            return  respsucc
        elif(sta == 'Failed'):
            respfail = {"responseid": reqData['requestid'], "responsefor":"Update data","responsesetto": reqData['requestsrc'],"responsedata": {"message":"Failed"}}
            return  respfail
    else:
        respfail = {"responseid": reqData['requestid'], "responsefor":"Update data","responsesetto": reqData['requestsrc'],"responsedata": {"message":"Error in Request"}}
        return  respfail

#1.7. Update All
def dbhash_processupdateall(req):
     pass



## Functions for DBInstance
# 1.1. Create
def dbinstance_processcreate(reqData):
    if isinstance(reqData, dict):
        #data_to_insert, ids_of_stored = generate_unique_ids('pagename','pagelayoutpropid',reqData, 'pagelayoutnprops')
        #print("all stored ids in db", data_to_insert, ids_of_stored)
        data_to_insert = reqData["requestdata"]
        data=tuple(data_to_insert.values())
        sta=dbilayer.insertIntoDBWithoutCondition('dbinstance',constants.column_dbinstance_table, data)
        if(sta == "Success"):
            respsucc={"responseid": reqData['requestid'], "responsefor": "Create", "responsesetto": reqData['requestsrc'], "response": {"message": "Success"}}
            return respsucc
        else:
            respfail={"responseid": reqData['requestid'], "responsefor": "Create", "responsesetto": reqData['requestsrc'], "response": {"message": "Some Error in Request"}}
            return respfail
    else:
        respfail={"responseid": reqData['requestid'], "responsefor": "Create", "responsesetto": reqData['requestsrc'], "response": {"message": "Error Encountered"}}
        return respfail


# 1.2. Read One Conditional
def dbinstance_processreadonecond(reqData):
    if isinstance(reqData, dict):
        condition_data=reqData['requestdata']
        condition = "dbinstanceid = {} AND status = '{}'".format(condition_data["dbinstanceid"], condition_data["status"])
        sta=dbilayer.readOneWithcondition('dbinstance', '*', condition,tablesdict.dbinstance_table)
        print(sta)
        #sta=common.list2dict(sta)
        if (len(sta) >= 1):
            respsucc={"responseid": reqData['requestid'], "responsefor": "Read one", "responsesetto": reqData['requestsrc'], "response": {"message": sta}}
            return respsucc
        else:
            respfail={"responseid": reqData['requestid'], "responsefor": "Read one", "responsesetto": reqData['requestsrc'], "response": {"message": "No data Received!"}}
            return respfail
    else:
        respfail={"responseid": reqData['requestid'], "responsefor": "Read one", "responsesetto": reqData['requestsrc'], "response": {"message": "Error Encountered"}}
        return respfail    


# 1.3. Read Multiple Conditional
def dbinstance_processreadmanycond(reqData):
    if isinstance(reqData, dict):
        condition_data=reqData['requestdata']
        condition_data = "status = '{}'".format(condition_data["status"])
        sta=dbilayer.readOneWithcondition('dbinstance', '*', condition_data,tablesdict.dbinstance_table)
        if (len(sta) >= 1):
            #sta=common.list2dict(sta)
            respsucc={"responseid": reqData['requestid'], "responsefor": "Read all with condition", "responsesetto": reqData['requestsrc'], "response": {"message": sta}}
            return respsucc
        else:
            respfail={"responseid": reqData['requestid'], "responsefor": "Read all with condition", "responsesetto": reqData['requestsrc'], "response":{"message": "No data received!"}}
            return respfail
    else:
        respfail={"responseid": reqData['requestid'], "responsefor": "Read all with condition", "responsesetto": reqData['requestsrc'], "response": {"message": "Error Encountered"}}
        return respfail
    

# 1.4. Read All without condition
def dbinstance_processreadmanywithoutcond(reqData):
    if isinstance(reqData, dict):
        if reqData['requestdata']['dbinstanceid'] == "all":
            sta=dbilayer.readallWithoutCondition('dbinstance', '*',tablesdict.dbinstance_table)
            #sta=common.list2dict(sta)
            if (len(sta) >= 1):
                respsucc={"responseid": reqData['requestid'], "responsefor": "Read all", "responsesetto": reqData['requestsrc'], "response": {"message": sta}}
                return respsucc
            else:
                respfail={"responseid": reqData['requestid'], "responsefor": "Read all", "responsesetto": reqData['requestsrc'], "response": {"message": "No data Received!"}}
                return respfail
        else:
            respfail={"responseid": reqData['requestid'], "responsefor": "Read all", "responsesetto": reqData['requestsrc'], "response": {"message": "Some error in request"}}
            return respfail    
    else:
        respfail={"responseid": reqData['requestid'], "responsefor": "Read all", "responsesetto": reqData['requestsrc'], "response": {"message": "Some error in request"}}
        return respfail
    
 #1.5. Delete One Conditional
def dbinstance_processdeleteonecond(reqData):
    if reqData['requestdata']['dbinstanceid']:
        data = reqData['requestdata']['dbinstanceid']
        sta = dbilayer.updateValuesIndb('dbInstance',"status ='9'" ,"dbinstanceid = {}".format(data))
        print(sta)
        if(sta == "Success"):
            respsucc = {"responseid": reqData['requestid'], "responsefor":"dbInstance_processdeleteonecond","responseto":"UI","responsedata": {"message":"Deleted Successfully"}}
            return  respsucc
        elif(sta == 'Failed'):
            respfail = {"responseid": reqData['requestid'], "responsefor":"dbInstance_processdeleteonecond","responseto":"UI","responsedata": {"message":"Delete request Failed"}}
            return  respfail
    else:
        respfail = {"responseid": reqData['requestid'], "responsefor":"dbInstance_processdeleteonecond","responseto":"UI","responsedata": {"message":"Error in Request"}}
        return  respfail   
    
#1.6. Update One Conditional
def dbinstance_processupdateonecond(reqData):
    if isinstance(reqData, dict):
        data=reqData['requestdata']
        dbinstancename = data['dbinstancename']
        dbinstanceid=data['dbinstanceid']
        dbportid=data['dbportid']
        dbipaddressid=data['dbipaddressid']
        dbusernameid=data['dbusernameid']
        dbpasswordid=data['dbpasswordid']
        dbschemaid=data['dbschemaid']
        status = data['status']
        updateStatement = "dbinstancename = '{}',dbportid= {},dbipaddressid= {},dbusernameid= {},dbpasswordid = {},dbschemaid = {},status = '{}'".format(dbinstancename,dbportid,dbipaddressid,dbusernameid,dbpasswordid,dbschemaid,status)
        condition = "dbinstanceid = {}".format(dbinstanceid)
        sta = dbilayer.updateValuesIndb('dbinstance', updateStatement, condition)
        print(sta)
        if(sta == "Success"):
            respsucc = {"responseid": reqData['requestid'], "responsefor":"Update data","responsesetto": reqData['requestsrc'],"responsedata": {"message":"Success"}}
            return  respsucc
        elif(sta == 'Failed'):
            respfail = {"responseid": reqData['requestid'], "responsefor":"Update data","responsesetto": reqData['requestsrc'],"responsedata": {"message":"Failed"}}
            return  respfail
    else:
        respfail = {"responseid": reqData['requestid'], "responsefor":"Update data","responsesetto": reqData['requestsrc'],"responsedata": {"message":"Error in Request"}}
        return  respfail

#1.7. Update All
def dbinstance_processupdateall(req):
     pass



## Functions for DBInvoice
# 1.1. Create
def dbinvoice_processcreate(reqData):
    if isinstance(reqData, dict):
        #data_to_insert, ids_of_stored = generate_unique_ids('pagename','pagelayoutpropid',reqData, 'pagelayoutnprops')
        #print("all stored ids in db", data_to_insert, ids_of_stored)
        data_to_insert = reqData["requestdata"]
        data=tuple(data_to_insert.values())
        sta=dbilayer.insertIntoDBWithoutCondition('dbinvoice',constants.column_dbinvoice_table, data)
        if(sta == "Success"):
            respsucc={"responseid": reqData['requestid'], "responsefor": "Create", "responsesetto": reqData['requestsrc'], "response": {"message": "Success"}}
            return respsucc
        else:
            respfail={"responseid": reqData['requestid'], "responsefor": "Create", "responsesetto": reqData['requestsrc'], "response": {"message": "Some Error in Request"}}
            return respfail
    else:
        respfail={"responseid": reqData['requestid'], "responsefor": "Create", "responsesetto": reqData['requestsrc'], "response": {"message": "Error Encountered"}}
        return respfail


# 1.2. Read One Conditional
def dbinvoice_processreadonecond(reqData):
    if isinstance(reqData, dict):
        condition_data=reqData['requestdata']
        condition = "dbinvoiceid = {} AND status = '{}'".format(condition_data["dbinvoiceid"], condition_data["status"])
        sta=dbilayer.readOneWithcondition('dbinvoice', '*', condition,tablesdict.dbinvoice_table)
        print(sta)
        #sta=common.list2dict(sta)
        if (len(sta) >= 1):
            respsucc={"responseid": reqData['requestid'], "responsefor": "Read one", "responsesetto": reqData['requestsrc'], "response": {"message": sta}}
            return respsucc
        else:
            respfail={"responseid": reqData['requestid'], "responsefor": "Read one", "responsesetto": reqData['requestsrc'], "response": {"message": "No data Received!"}}
            return respfail
    else:
        respfail={"responseid": reqData['requestid'], "responsefor": "Read one", "responsesetto": reqData['requestsrc'], "response": {"message": "Error Encountered"}}
        return respfail    


# 1.3. Read Multiple Conditional
def dbinvoice_processreadmanycond(reqData):
    if isinstance(reqData, dict):
        condition_data=reqData['requestdata']
        condition_data = "status = '{}'".format(condition_data["status"])
        sta=dbilayer.readOneWithcondition('dbinvoice', '*', condition_data,tablesdict.dbinvoice_table)
        if (len(sta) >= 1):
            #sta=common.list2dict(sta)
            respsucc={"responseid": reqData['requestid'], "responsefor": "Read all with condition", "responsesetto": reqData['requestsrc'], "response": {"message": sta}}
            return respsucc
        else:
            respfail={"responseid": reqData['requestid'], "responsefor": "Read all with condition", "responsesetto": reqData['requestsrc'], "response":{"message": "No data received!"}}
            return respfail
    else:
        respfail={"responseid": reqData['requestid'], "responsefor": "Read all with condition", "responsesetto": reqData['requestsrc'], "response": {"message": "Error Encountered"}}
        return respfail
    

# 1.4. Read All without condition
def dbinvoice_processreadmanywithoutcond(reqData):
    if isinstance(reqData, dict):
        if reqData['requestdata']['dbinvoiceid'] == "all":
            sta=dbilayer.readallWithoutCondition('dbinvoice', '*',tablesdict.dbinvoice_table)
            #sta=common.list2dict(sta)
            if (len(sta) >= 1):
                respsucc={"responseid": reqData['requestid'], "responsefor": "Read all", "responsesetto": reqData['requestsrc'], "response": {"message": sta}}
                return respsucc
            else:
                respfail={"responseid": reqData['requestid'], "responsefor": "Read all", "responsesetto": reqData['requestsrc'], "response": {"message": "No data Received!"}}
                return respfail
        else:
            respfail={"responseid": reqData['requestid'], "responsefor": "Read all", "responsesetto": reqData['requestsrc'], "response": {"message": "Some error in request"}}
            return respfail    
    else:
        respfail={"responseid": reqData['requestid'], "responsefor": "Read all", "responsesetto": reqData['requestsrc'], "response": {"message": "Some error in request"}}
        return respfail
    
 #1.5. Delete One Conditional
def dbinvoice_processdeleteonecond(reqData):
    if reqData['requestdata']['dbinvoiceid']:
        data = reqData['requestdata']['dbinvoiceid']
        sta = dbilayer.updateValuesIndb('dbinvoice',"status ='9'" ,"dbinvoiceid = {}".format(data))
        print(sta)
        if(sta == "Success"):
            respsucc = {"responseid": reqData['requestid'], "responsefor":"dbInvoice_processdeleteonecond","responseto":"UI","responsedata": {"message":"Deleted Successfully"}}
            return  respsucc
        elif(sta == 'Failed'):
            respfail = {"responseid": reqData['requestid'], "responsefor":"dbInvoice_processdeleteonecond","responseto":"UI","responsedata": {"message":"Delete request Failed"}}
            return  respfail
    else:
        respfail = {"responseid": reqData['requestid'], "responsefor":"dbInvoice_processdeleteonecond","responseto":"UI","responsedata": {"message":"Error in Request"}}
        return  respfail   
    
#1.6. Update One Conditional
def dbinvoice_processupdateonecond(reqData):
    if isinstance(reqData, dict):
        data=reqData['requestdata']
        dbinvoicenumber = data['dbinvoicenumber']
        dbinvoiceid=data['dbinvoiceid']
        dbinvoiceperiodstartdate=data['dbinvoiceperiodstartdate']
        dbinvoicelineitemid=data['dbinvoicelineitemid']
        dbcustomerid=data['dbcustomerid']
        dbinvoicedate=data['dbinvoicedate']
        dbinvoiceperiodenddate=data['dbinvoiceperiodenddate']
        dbchargeid=data['dbchargeid']
        status = data['status']
        updateStatement = "dbinvoicenumber = '{}',dbinvoiceperiodstartdate= '{}',dbinvoicelineitemid= {},dbcustomerid= {}, dbinvoicedate= '{}',dbinvoiceperiodenddate = '{}',dbchargeid= {},status = '{}'".format(dbinvoicenumber,dbinvoiceperiodstartdate,dbinvoicelineitemid,dbcustomerid,dbinvoicedate,dbinvoiceperiodenddate,dbchargeid,status)
        condition = "dbinvoiceid = {}".format(dbinvoiceid)
        sta = dbilayer.updateValuesIndb('dbInvoice', updateStatement, condition)
        print(sta)
        if(sta == "Success"):
            respsucc = {"responseid": reqData['requestid'], "responsefor":"Update data","responsesetto": reqData['requestsrc'],"responsedata": {"message":"Success"}}
            return  respsucc
        elif(sta == 'Failed'):
            respfail = {"responseid": reqData['requestid'], "responsefor":"Update data","responsesetto": reqData['requestsrc'],"responsedata": {"message":"Failed"}}
            return  respfail
    else:
        respfail = {"responseid": reqData['requestid'], "responsefor":"Update data","responsesetto": reqData['requestsrc'],"responsedata": {"message":"Error in Request"}}
        return  respfail

#1.7. Update All
def dbinvoice_processupdateall(req):
     pass



## Functions for DBInvoiceLineItem
# 1.1. Create
def dbinvoicelineitem_processcreate(reqData):
    if isinstance(reqData, dict):
        #data_to_insert, ids_of_stored = generate_unique_ids('pagename','pagelayoutpropid',reqData, 'pagelayoutnprops')
        #print("all stored ids in db", data_to_insert, ids_of_stored)
        data_to_insert = reqData["requestdata"]
        data=tuple(data_to_insert.values())
        sta=dbilayer.insertIntoDBWithoutCondition('dbinvoicelineitem',constants.column_dbinvoicelineitem_table, data)
        if(sta == "Success"):
            respsucc={"responseid": reqData['requestid'], "responsefor": "Create", "responsesetto": reqData['requestsrc'], "response": {"message": "Success"}}
            return respsucc
        else:
            respfail={"responseid": reqData['requestid'], "responsefor": "Create", "responsesetto": reqData['requestsrc'], "response": {"message": "Some Error in Request"}}
            return respfail
    else:
        respfail={"responseid": reqData['requestid'], "responsefor": "Create", "responsesetto": reqData['requestsrc'], "response": {"message": "Error Encountered"}}
        return respfail


# 1.2. Read One Conditional
def dbinvoicelineitem_processreadonecond(reqData):
    if isinstance(reqData, dict):
        condition_data=reqData['requestdata']
        condition = "dbinvoicelineitemid = {} AND status = '{}'".format(condition_data["dbinvoicelineitemid"], condition_data["status"])
        sta=dbilayer.readOneWithcondition('dbinvoicelineitem', '*', condition,tablesdict.dbinvoicelineitem_table)
        print(sta)
        #sta=common.list2dict(sta)
        if (len(sta) >= 1):
            respsucc={"responseid": reqData['requestid'], "responsefor": "Read one", "responsesetto": reqData['requestsrc'], "response": {"message": sta}}
            return respsucc
        else:
            respfail={"responseid": reqData['requestid'], "responsefor": "Read one", "responsesetto": reqData['requestsrc'], "response": {"message": "No data Received!"}}
            return respfail
    else:
        respfail={"responseid": reqData['requestid'], "responsefor": "Read one", "responsesetto": reqData['requestsrc'], "response": {"message": "Error Encountered"}}
        return respfail    


# 1.3. Read Multiple Conditional
def dbinvoicelineitem_processreadmanycond(reqData):
    if isinstance(reqData, dict):
        condition_data=reqData['requestdata']
        condition_data = "status = '{}'".format(condition_data["status"])
        sta=dbilayer.readOneWithcondition('dbinvoicelineitem', '*', condition_data,tablesdict.dbinvoicelineitem_table)
        if (len(sta) >= 1):
            #sta=common.list2dict(sta)
            respsucc={"responseid": reqData['requestid'], "responsefor": "Read all with condition", "responsesetto": reqData['requestsrc'], "response": {"message": sta}}
            return respsucc
        else:
            respfail={"responseid": reqData['requestid'], "responsefor": "Read all with condition", "responsesetto": reqData['requestsrc'], "response":{"message": "No data received!"}}
            return respfail
    else:
        respfail={"responseid": reqData['requestid'], "responsefor": "Read all with condition", "responsesetto": reqData['requestsrc'], "response": {"message": "Error Encountered"}}
        return respfail
    

# 1.4. Read All without condition
def dbinvoicelineitem_processreadmanywithoutcond(reqData):
    if isinstance(reqData, dict):
        if reqData['requestdata']['dbinvoicelineitemid'] == "all":
            sta=dbilayer.readallWithoutCondition('dbinvoicelineitem', '*',tablesdict.dbinvoicelineitem_table)
            #sta=common.list2dict(sta)
            if (len(sta) >= 1):
                respsucc={"responseid": reqData['requestid'], "responsefor": "Read all", "responsesetto": reqData['requestsrc'], "response": {"message": sta}}
                return respsucc
            else:
                respfail={"responseid": reqData['requestid'], "responsefor": "Read all", "responsesetto": reqData['requestsrc'], "response": {"message": "No data Received!"}}
                return respfail
        else:
            respfail={"responseid": reqData['requestid'], "responsefor": "Read all", "responsesetto": reqData['requestsrc'], "response": {"message": "Some error in request"}}
            return respfail    
    else:
        respfail={"responseid": reqData['requestid'], "responsefor": "Read all", "responsesetto": reqData['requestsrc'], "response": {"message": "Some error in request"}}
        return respfail
    
 #1.5. Delete One Conditional
def dbinvoicelineitem_processdeleteonecond(reqData):
    if reqData['requestdata']['dbinvoicelineitemid']:
        data = reqData['requestdata']['dbinvoicelineitemid']
        sta = dbilayer.updateValuesIndb('dbinvoicelineitem',"status ='9'" ,"dbinvoicelineitemid = {}".format(data))
        print(sta)
        if(sta == "Success"):
            respsucc = {"responseid": reqData['requestid'], "responsefor":"dbInvoiceLineItem_processdeleteonecond","responseto":"UI","responsedata": {"message":"Deleted Successfully"}}
            return  respsucc
        elif(sta == 'Failed'):
            respfail = {"responseid": reqData['requestid'], "responsefor":"dbInvoiceLineItem_processdeleteonecond","responseto":"UI","responsedata": {"message":"Delete request Failed"}}
            return  respfail
    else:
        respfail = {"responseid": reqData['requestid'], "responsefor":"dbInvoiceLineItem_processdeleteonecond","responseto":"UI","responsedata": {"message":"Error in Request"}}
        return  respfail   
    
#1.6. Update One Conditional
def dbinvoicelineitem_processupdateonecond(reqData):
    if isinstance(reqData, dict):
        data=reqData['requestdata']
        dbinvoicelineitemname = data['dbinvoicelineitemname']
        dbinvoicelineitemid=data['dbinvoicelineitemid']
        status = data['status']
        updateStatement = "dbinvoicelineitemname = '{}',status = '{}'".format(dbinvoicelineitemname,status)
        condition = "dbinvoicelineitemid = {}".format(dbinvoicelineitemid)
        sta = dbilayer.updateValuesIndb('dbinvoicelineitem', updateStatement, condition)
        print(sta)
        if(sta == "Success"):
            respsucc = {"responseid": reqData['requestid'], "responsefor":"Update data","responsesetto": reqData['requestsrc'],"responsedata": {"message":"Success"}}
            return  respsucc
        elif(sta == 'Failed'):
            respfail = {"responseid": reqData['requestid'], "responsefor":"Update data","responsesetto": reqData['requestsrc'],"responsedata": {"message":"Failed"}}
            return  respfail
    else:
        respfail = {"responseid": reqData['requestid'], "responsefor":"Update data","responsesetto": reqData['requestsrc'],"responsedata": {"message":"Error in Request"}}
        return  respfail

#1.7. Update All
def dbinvoicelineitem_processupdateall(req):
     pass



## Functions for DBIpAddress
# 1.1. Create
def dbipaddress_processcreate(reqData):
    if isinstance(reqData, dict):
        #data_to_insert, ids_of_stored = generate_unique_ids('pagename','pagelayoutpropid',reqData, 'pagelayoutnprops')
        #print("all stored ids in db", data_to_insert, ids_of_stored)
        data_to_insert = reqData["requestdata"]
        data=tuple(data_to_insert.values())
        sta=dbilayer.insertIntoDBWithoutCondition('dbipaddress',constants.column_dbipaddress_table, data)
        if(sta == "Success"):
            respsucc={"responseid": reqData['requestid'], "responsefor": "Create", "responsesetto": reqData['requestsrc'], "response": {"message": "Success"}}
            return respsucc
        else:
            respfail={"responseid": reqData['requestid'], "responsefor": "Create", "responsesetto": reqData['requestsrc'], "response": {"message": "Some Error in Request"}}
            return respfail
    else:
        respfail={"responseid": reqData['requestid'], "responsefor": "Create", "responsesetto": reqData['requestsrc'], "response": {"message": "Error Encountered"}}
        return respfail


# 1.2. Read One Conditional
def dbipaddress_processreadonecond(reqData):
    if isinstance(reqData, dict):
        condition_data=reqData['requestdata']
        condition = "dbipaddressid = {} AND status = '{}'".format(condition_data["dbipaddressid"], condition_data["status"])
        sta=dbilayer.readOneWithcondition('dbipaddress', '*', condition,tablesdict.dbipaddress_table)
        print(sta)
        #sta=common.list2dict(sta)
        if (len(sta) >= 1):
            respsucc={"responseid": reqData['requestid'], "responsefor": "Read one", "responsesetto": reqData['requestsrc'], "response": {"message": sta}}
            return respsucc
        else:
            respfail={"responseid": reqData['requestid'], "responsefor": "Read one", "responsesetto": reqData['requestsrc'], "response": {"message": "No data Received!"}}
            return respfail
    else:
        respfail={"responseid": reqData['requestid'], "responsefor": "Read one", "responsesetto": reqData['requestsrc'], "response": {"message": "Error Encountered"}}
        return respfail    


# 1.3. Read Multiple Conditional
def dbipaddress_processreadmanycond(reqData):
    if isinstance(reqData, dict):
        condition_data=reqData['requestdata']
        condition_data = "status = '{}'".format(condition_data["status"])
        sta=dbilayer.readOneWithcondition('dbipaddress', '*', condition_data,tablesdict.dbipaddress_table)
        if (len(sta) >= 1):
            #sta=common.list2dict(sta)
            respsucc={"responseid": reqData['requestid'], "responsefor": "Read all with condition", "responsesetto": reqData['requestsrc'], "response": {"message": sta}}
            return respsucc
        else:
            respfail={"responseid": reqData['requestid'], "responsefor": "Read all with condition", "responsesetto": reqData['requestsrc'], "response":{"message": "No data received!"}}
            return respfail
    else:
        respfail={"responseid": reqData['requestid'], "responsefor": "Read all with condition", "responsesetto": reqData['requestsrc'], "response": {"message": "Error Encountered"}}
        return respfail
    

# 1.4. Read All without condition
def dbipaddress_processreadmanywithoutcond(reqData):
    if isinstance(reqData, dict):
        if reqData['requestdata']['dbipaddressid'] == "all":
            sta=dbilayer.readallWithoutCondition('dbipaddress', '*',tablesdict.dbipaddress_table)
            #sta=common.list2dict(sta)
            if (len(sta) >= 1):
                respsucc={"responseid": reqData['requestid'], "responsefor": "Read all", "responsesetto": reqData['requestsrc'], "response": {"message": sta}}
                return respsucc
            else:
                respfail={"responseid": reqData['requestid'], "responsefor": "Read all", "responsesetto": reqData['requestsrc'], "response": {"message": "No data Received!"}}
                return respfail
        else:
            respfail={"responseid": reqData['requestid'], "responsefor": "Read all", "responsesetto": reqData['requestsrc'], "response": {"message": "Some error in request"}}
            return respfail    
    else:
        respfail={"responseid": reqData['requestid'], "responsefor": "Read all", "responsesetto": reqData['requestsrc'], "response": {"message": "Some error in request"}}
        return respfail
    
 #1.5. Delete One Conditional
def dbipaddress_processdeleteonecond(reqData):
    if reqData['requestdata']['dbipaddressid']:
        data = reqData['requestdata']['dbipaddressid']
        sta = dbilayer.updateValuesIndb('dbipaddress',"status ='9'" ,"dbipaddressid = {}".format(data))
        print(sta)
        if(sta == "Success"):
            respsucc = {"responseid": reqData['requestid'], "responsefor":"dbIpAddress_processdeleteonecond","responseto":"UI","responsedata": {"message":"Deleted Successfully"}}
            return  respsucc
        elif(sta == 'Failed'):
            respfail = {"responseid": reqData['requestid'], "responsefor":"dbIpAddress_processdeleteonecond","responseto":"UI","responsedata": {"message":"Delete request Failed"}}
            return  respfail
    else:
        respfail = {"responseid": reqData['requestid'], "responsefor":"dbIpAddress_processdeleteonecond","responseto":"UI","responsedata": {"message":"Error in Request"}}
        return  respfail   
    
#1.6. Update One Conditional
def dbipaddress_processupdateonecond(reqData):
    if isinstance(reqData, dict):
        data=reqData['requestdata']
        dbipaddressvalue = data['dbipaddressvalue']
        dbipaddressid=data['dbipaddressid']
        dbipaddressdesc=data['dbipaddressdesc']
        dbusernameid=data['dbusernameid']
        dbpasswordid=data['dbpasswordid']
        status = data['status']
        updateStatement = "dbipaddressvalue= '{}',dbipaddressdesc= '{}',dbusernameid= {},dbpasswordid= {},status = '{}'".format(dbipaddressvalue,dbipaddressdesc,dbusernameid,dbpasswordid,status)
        condition = "dbipaddressid = {}".format(dbipaddressid)
        sta = dbilayer.updateValuesIndb('dbipaddress', updateStatement, condition)
        print(sta)
        if(sta == "Success"):
            respsucc = {"responseid": reqData['requestid'], "responsefor":"Update data","responsesetto": reqData['requestsrc'],"responsedata": {"message":"Success"}}
            return  respsucc
        elif(sta == 'Failed'):
            respfail = {"responseid": reqData['requestid'], "responsefor":"Update data","responsesetto": reqData['requestsrc'],"responsedata": {"message":"Failed"}}
            return  respfail
    else:
        respfail = {"responseid": reqData['requestid'], "responsefor":"Update data","responsesetto": reqData['requestsrc'],"responsedata": {"message":"Error in Request"}}
        return  respfail

#1.7. Update All
def dbipaddress_processupdateall(req):
     pass



## Functions for DBKYC
# 1.1. Create
def dbkyc_processcreate(reqData):
    if isinstance(reqData, dict):
        #data_to_insert, ids_of_stored = generate_unique_ids('pagename','pagelayoutpropid',reqData, 'pagelayoutnprops')
        #print("all stored ids in db", data_to_insert, ids_of_stored)
        data_to_insert = reqData["requestdata"]
        data=tuple(data_to_insert.values())
        sta=dbilayer.insertIntoDBWithoutCondition('dbkyc',constants.column_dbkyc_table, data)
        if(sta == "Success"):
            respsucc={"responseid": reqData['requestid'], "responsefor": "Create", "responsesetto": reqData['requestsrc'], "response": {"message": "Success"}}
            return respsucc
        else:
            respfail={"responseid": reqData['requestid'], "responsefor": "Create", "responsesetto": reqData['requestsrc'], "response": {"message": "Some Error in Request"}}
            return respfail
    else:
        respfail={"responseid": reqData['requestid'], "responsefor": "Create", "responsesetto": reqData['requestsrc'], "response": {"message": "Error Encountered"}}
        return respfail


# 1.2. Read One Conditional
def dbkyc_processreadonecond(reqData):
    if isinstance(reqData, dict):
        condition_data=reqData['requestdata']
        condition = "dbkycid = {} AND status = '{}'".format(condition_data["dbkycid"], condition_data["status"])
        sta=dbilayer.readOneWithcondition('dbkyc', '*', condition,tablesdict.dbkyc_table)
        print(sta)
        #sta=common.list2dict(sta)
        if (len(sta) >= 1):
            respsucc={"responseid": reqData['requestid'], "responsefor": "Read one", "responsesetto": reqData['requestsrc'], "response": {"message": sta}}
            return respsucc
        else:
            respfail={"responseid": reqData['requestid'], "responsefor": "Read one", "responsesetto": reqData['requestsrc'], "response": {"message": "No data Received!"}}
            return respfail
    else:
        respfail={"responseid": reqData['requestid'], "responsefor": "Read one", "responsesetto": reqData['requestsrc'], "response": {"message": "Error Encountered"}}
        return respfail    


# 1.3. Read Multiple Conditional
def dbkyc_processreadmanycond(reqData):
    if isinstance(reqData, dict):
        condition_data=reqData['requestdata']
        condition_data = "status = '{}'".format(condition_data["status"])
        sta=dbilayer.readOneWithcondition('dbkyc', '*', condition_data,tablesdict.dbkyc_table)
        if (len(sta) >= 1):
            #sta=common.list2dict(sta)
            respsucc={"responseid": reqData['requestid'], "responsefor": "Read all with condition", "responsesetto": reqData['requestsrc'], "response": {"message": sta}}
            return respsucc
        else:
            respfail={"responseid": reqData['requestid'], "responsefor": "Read all with condition", "responsesetto": reqData['requestsrc'], "response":{"message": "No data received!"}}
            return respfail
    else:
        respfail={"responseid": reqData['requestid'], "responsefor": "Read all with condition", "responsesetto": reqData['requestsrc'], "response": {"message": "Error Encountered"}}
        return respfail
    

# 1.4. Read All without condition
def dbkyc_processreadmanywithoutcond(reqData):
    if isinstance(reqData, dict):
        if reqData['requestdata']['dbkycid'] == "all":
            sta=dbilayer.readallWithoutCondition('dbkyc', '*',tablesdict.dbkyc_table)
            #sta=common.list2dict(sta)
            if (len(sta) >= 1):
                respsucc={"responseid": reqData['requestid'], "responsefor": "Read all", "responsesetto": reqData['requestsrc'], "response": {"message": sta}}
                return respsucc
            else:
                respfail={"responseid": reqData['requestid'], "responsefor": "Read all", "responsesetto": reqData['requestsrc'], "response": {"message": "No data Received!"}}
                return respfail
        else:
            respfail={"responseid": reqData['requestid'], "responsefor": "Read all", "responsesetto": reqData['requestsrc'], "response": {"message": "Some error in request"}}
            return respfail    
    else:
        respfail={"responseid": reqData['requestid'], "responsefor": "Read all", "responsesetto": reqData['requestsrc'], "response": {"message": "Some error in request"}}
        return respfail
    
 #1.5. Delete One Conditional
def dbkyc_processdeleteonecond(reqData):
    if reqData['requestdata']['dbkycid']:
        data = reqData['requestdata']['dbkycid']
        sta = dbilayer.updateValuesIndb('dbkyc',"status ='9'" ,"dbkycid = {}".format(data))
        print(sta)
        if(sta == "Success"):
            respsucc = {"responseid": reqData['requestid'], "responsefor":"dbKYC_processdeleteonecond","responseto":"UI","responsedata": {"message":"Deleted Successfully"}}
            return  respsucc
        elif(sta == 'Failed'):
            respfail = {"responseid": reqData['requestid'], "responsefor":"dbKYC_processdeleteonecond","responseto":"UI","responsedata": {"message":"Delete request Failed"}}
            return  respfail
    else:
        respfail = {"responseid": reqData['requestid'], "responsefor":"dbKYC_processdeleteonecond","responseto":"UI","responsedata": {"message":"Error in Request"}}
        return  respfail   
    
#1.6. Update One Conditional
def dbkyc_processupdateonecond(reqData):
    if isinstance(reqData, dict):
        data=reqData['requestdata']
        dbkycdesc = data['dbkycdesc']
        dbkycid=data['dbkycid']
        dbtypeid=data['dbtypeid']
        status = data['status']
        updateStatement = "dbkycdesc= '{}',dbtypeid={},status = '{}'".format(dbkycdesc,dbtypeid,status)
        condition = "dbkycid = {}".format(dbkycid)
        sta = dbilayer.updateValuesIndb('dbkyc', updateStatement, condition)
        print(sta)
        if(sta == "Success"):
            respsucc = {"responseid": reqData['requestid'], "responsefor":"Update data","responsesetto": reqData['requestsrc'],"responsedata": {"message":"Success"}}
            return  respsucc
        elif(sta == 'Failed'):
            respfail = {"responseid": reqData['requestid'], "responsefor":"Update data","responsesetto": reqData['requestsrc'],"responsedata": {"message":"Failed"}}
            return  respfail
    else:
        respfail = {"responseid": reqData['requestid'], "responsefor":"Update data","responsesetto": reqData['requestsrc'],"responsedata": {"message":"Error in Request"}}
        return  respfail

#1.7. Update All
def dbkyc_processupdateall(req):
     pass



## Functions for dbname
# 1.1. Create
def dbname_processcreate(reqData):
    if isinstance(reqData, dict):
        #data_to_insert, ids_of_stored = generate_unique_ids('pagename','pagelayoutpropid',reqData, 'pagelayoutnprops')
        #print("all stored ids in db", data_to_insert, ids_of_stored)
        data_to_insert = reqData["requestdata"]
        data=tuple(data_to_insert.values())
        sta=dbilayer.insertIntoDBWithoutCondition('dbname',constants.column_dbname_table, data)
        if(sta == "Success"):
            respsucc={"responseid": reqData['requestid'], "responsefor": "Create", "responsesetto": reqData['requestsrc'], "response": {"message": "Success"}}
            return respsucc
        else:
            respfail={"responseid": reqData['requestid'], "responsefor": "Create", "responsesetto": reqData['requestsrc'], "response": {"message": "Some Error in Request"}}
            return respfail
    else:
        respfail={"responseid": reqData['requestid'], "responsefor": "Create", "responsesetto": reqData['requestsrc'], "response": {"message": "Error Encountered"}}
        return respfail


# 1.2. Read One Conditional
def dbname_processreadonecond(reqData):
    if isinstance(reqData, dict):
        condition_data=reqData['requestdata']
        condition = "dbnameid = {} AND status = '{}'".format(condition_data["dbnameid"], condition_data["status"])
        sta=dbilayer.readOneWithcondition('dbname', '*', condition,tablesdict.dbname_table)
        print(sta)
        #sta=common.list2dict(sta)
        if (len(sta) >= 1):
            respsucc={"responseid": reqData['requestid'], "responsefor": "Read one", "responsesetto": reqData['requestsrc'], "response": {"message": sta}}
            return respsucc
        else:
            respfail={"responseid": reqData['requestid'], "responsefor": "Read one", "responsesetto": reqData['requestsrc'], "response": {"message": "No data Received!"}}
            return respfail
    else:
        respfail={"responseid": reqData['requestid'], "responsefor": "Read one", "responsesetto": reqData['requestsrc'], "response": {"message": "Error Encountered"}}
        return respfail    


# 1.3. Read Multiple Conditional
def dbname_processreadmanycond(reqData):
    if isinstance(reqData, dict):
        condition_data=reqData['requestdata']
        condition_data = "status = '{}'".format(condition_data["status"])
        sta=dbilayer.readOneWithcondition('dbname', '*', condition_data,tablesdict.dbname_table)
        if (len(sta) >= 1):
            #sta=common.list2dict(sta)
            respsucc={"responseid": reqData['requestid'], "responsefor": "Read all with condition", "responsesetto": reqData['requestsrc'], "response": {"message": sta}}
            return respsucc
        else:
            respfail={"responseid": reqData['requestid'], "responsefor": "Read all with condition", "responsesetto": reqData['requestsrc'], "response":{"message": "No data received!"}}
            return respfail
    else:
        respfail={"responseid": reqData['requestid'], "responsefor": "Read all with condition", "responsesetto": reqData['requestsrc'], "response": {"message": "Error Encountered"}}
        return respfail
    

# 1.4. Read All without condition
def dbname_processreadmanywithoutcond(reqData):
    if isinstance(reqData, dict):
        if reqData['requestdata']['dbnameid'] == "all":
            sta=dbilayer.readallWithoutCondition('dbname', '*',tablesdict.dbname_table)
            #sta=common.list2dict(sta)
            if (len(sta) >= 1):
                respsucc={"responseid": reqData['requestid'], "responsefor": "Read all", "responsesetto": reqData['requestsrc'], "response": {"message": sta}}
                return respsucc
            else:
                respfail={"responseid": reqData['requestid'], "responsefor": "Read all", "responsesetto": reqData['requestsrc'], "response": {"message": "No data Received!"}}
                return respfail
        else:
            respfail={"responseid": reqData['requestid'], "responsefor": "Read all", "responsesetto": reqData['requestsrc'], "response": {"message": "Some error in request"}}
            return respfail    
    else:
        respfail={"responseid": reqData['requestid'], "responsefor": "Read all", "responsesetto": reqData['requestsrc'], "response": {"message": "Some error in request"}}
        return respfail
    
 #1.5. Delete One Conditional
def dbname_processdeleteonecond(reqData):
    if reqData['requestdata']['dbnameid']:
        data = reqData['requestdata']['dbnameid']
        sta = dbilayer.updateValuesIndb('dbname',"status ='9'" ,"dbnameid = {}".format(data))
        print(sta)
        if(sta == "Success"):
            respsucc = {"responseid": reqData['requestid'], "responsefor":"dbName_processdeleteonecond","responseto":"UI","responsedata": {"message":"Deleted Successfully"}}
            return  respsucc
        elif(sta == 'Failed'):
            respfail = {"responseid": reqData['requestid'], "responsefor":"dbName_processdeleteonecond","responseto":"UI","responsedata": {"message":"Delete request Failed"}}
            return  respfail
    else:
        respfail = {"responseid": reqData['requestid'], "responsefor":"dbName_processdeleteonecond","responseto":"UI","responsedata": {"message":"Error in Request"}}
        return  respfail   
    
#1.6. Update One Conditional
def dbname_processupdateonecond(reqData):
    if isinstance(reqData, dict):
        data=reqData['requestdata']
        dbname = data['dbname']
        dbnameid=data['dbnameid']
        dbschemaid=data['dbschemaid']
        dbcategoryid=data['dbcategoryid']
        status = data['status']
        updateStatement = "dbname= '{}',dbschemaid={},dbcategoryid={},status = '{}'".format(dbname,dbschemaid,dbcategoryid,status)
        condition = "dbnameid = {}".format(dbnameid)
        sta = dbilayer.updateValuesIndb('dbname', updateStatement, condition)
        print(sta)
        if(sta == "Success"):
            respsucc = {"responseid": reqData['requestid'], "responsefor":"Update data","responsesetto": reqData['requestsrc'],"responsedata": {"message":"Success"}}
            return  respsucc
        elif(sta == 'Failed'):
            respfail = {"responseid": reqData['requestid'], "responsefor":"Update data","responsesetto": reqData['requestsrc'],"responsedata": {"message":"Failed"}}
            return  respfail
    else:
        respfail = {"responseid": reqData['requestid'], "responsefor":"Update data","responsesetto": reqData['requestsrc'],"responsedata": {"message":"Error in Request"}}
        return  respfail

#1.7. Update All
def dbname_processupdateall(req):
     pass



## Functions for dbOrders
# 1.1. Create
def dborders_processcreate(reqData):
    if isinstance(reqData, dict):
        #data_to_insert, ids_of_stored = generate_unique_ids('pagename','pagelayoutpropid',reqData, 'pagelayoutnprops')
        #print("all stored ids in db", data_to_insert, ids_of_stored)
        data_to_insert = reqData["requestdata"]
        data=tuple(data_to_insert.values())
        sta=dbilayer.insertIntoDBWithoutCondition('dborders',constants.column_dborders_table, data)
        if(sta == "Success"):
            respsucc={"responseid": reqData['requestid'], "responsefor": "Create", "responsesetto": reqData['requestsrc'], "response": {"message": "Success"}}
            return respsucc
        else:
            respfail={"responseid": reqData['requestid'], "responsefor": "Create", "responsesetto": reqData['requestsrc'], "response": {"message": "Some Error in Request"}}
            return respfail
    else:
        respfail={"responseid": reqData['requestid'], "responsefor": "Create", "responsesetto": reqData['requestsrc'], "response": {"message": "Error Encountered"}}
        return respfail


# 1.2. Read One Conditional
def dborders_processreadonecond(reqData):
    if isinstance(reqData, dict):
        condition_data=reqData['requestdata']
        condition = "dborderid = {} AND status = '{}'".format(condition_data["dborderid"], condition_data["status"])
        sta=dbilayer.readOneWithcondition('dborders', '*', condition,tablesdict.dborders_table)
        print(sta)
        #sta=common.list2dict(sta)
        if (len(sta) >= 1):
            respsucc={"responseid": reqData['requestid'], "responsefor": "Read one", "responsesetto": reqData['requestsrc'], "response": {"message": sta}}
            return respsucc
        else:
            respfail={"responseid": reqData['requestid'], "responsefor": "Read one", "responsesetto": reqData['requestsrc'], "response": {"message": "No data Received!"}}
            return respfail
    else:
        respfail={"responseid": reqData['requestid'], "responsefor": "Read one", "responsesetto": reqData['requestsrc'], "response": {"message": "Error Encountered"}}
        return respfail    


# 1.3. Read Multiple Conditional
def dborders_processreadmanycond(reqData):
    if isinstance(reqData, dict):
        condition_data=reqData['requestdata']
        condition_data = "status = '{}'".format(condition_data["status"])
        sta=dbilayer.readOneWithcondition('dborders', '*', condition_data,tablesdict.dborders_table)
        if (len(sta) >= 1):
            #sta=common.list2dict(sta)
            respsucc={"responseid": reqData['requestid'], "responsefor": "Read all with condition", "responsesetto": reqData['requestsrc'], "response": {"message": sta}}
            return respsucc
        else:
            respfail={"responseid": reqData['requestid'], "responsefor": "Read all with condition", "responsesetto": reqData['requestsrc'], "response":{"message": "No data received!"}}
            return respfail
    else:
        respfail={"responseid": reqData['requestid'], "responsefor": "Read all with condition", "responsesetto": reqData['requestsrc'], "response": {"message": "Error Encountered"}}
        return respfail
    

# 1.4. Read All without condition
def dborders_processreadmanywithoutcond(reqData):
    if isinstance(reqData, dict):
        if reqData['requestdata']['dborderid'] == "all":
            sta=dbilayer.readallWithoutCondition('dborders', '*',tablesdict.dborders_table)
            #sta=common.list2dict(sta)
            if (len(sta) >= 1):
                respsucc={"responseid": reqData['requestid'], "responsefor": "Read all", "responsesetto": reqData['requestsrc'], "response": {"message": sta}}
                return respsucc
            else:
                respfail={"responseid": reqData['requestid'], "responsefor": "Read all", "responsesetto": reqData['requestsrc'], "response": {"message": "No data Received!"}}
                return respfail
        else:
            respfail={"responseid": reqData['requestid'], "responsefor": "Read all", "responsesetto": reqData['requestsrc'], "response": {"message": "Some error in request"}}
            return respfail    
    else:
        respfail={"responseid": reqData['requestid'], "responsefor": "Read all", "responsesetto": reqData['requestsrc'], "response": {"message": "Some error in request"}}
        return respfail
    
 #1.5. Delete One Conditional
def dborders_processdeleteonecond(reqData):
    if reqData['requestdata']['dborderid']:
        data = reqData['requestdata']['dborderid']
        sta = dbilayer.updateValuesIndb('dbOrders',"status ='9'" ,"dborderid = {}".format(data))
        print(sta)
        if(sta == "Success"):
            respsucc = {"responseid": reqData['requestid'], "responsefor":"dbOrders_processdeleteonecond","responseto":"UI","responsedata": {"message":"Deleted Successfully"}}
            return  respsucc
        elif(sta == 'Failed'):
            respfail = {"responseid": reqData['requestid'], "responsefor":"dbOrders_processdeleteonecond","responseto":"UI","responsedata": {"message":"Delete request Failed"}}
            return  respfail
    else:
        respfail = {"responseid": reqData['requestid'], "responsefor":"dbOrders_processdeleteonecond","responseto":"UI","responsedata": {"message":"Error in Request"}}
        return  respfail   
    
#1.6. Update One Conditional
def dborders_processupdateonecond(reqData):
    if isinstance(reqData, dict):
        data=reqData['requestdata']
        dbordersid = data['dborderid']
        dbordername=data['dbordername']
        dbbillingid=data['dbbillingid']
        dbpackageid=data['dbpackageid']
        status = data['status']
        updateStatement = "dbordername= '{}',dbbillingid= {},dbpackageid = {},status = '{}'".format(dbordername,dbbillingid,dbpackageid,status)
        condition = "dborderid = {}".format(dbordersid)
        sta = dbilayer.updateValuesIndb('dborders', updateStatement, condition)
        print(sta)
        if(sta == "Success"):
            respsucc = {"responseid": reqData['requestid'], "responsefor":"Update data","responsesetto": reqData['requestsrc'],"responsedata": {"message":"Success"}}
            return  respsucc
        elif(sta == 'Failed'):
            respfail = {"responseid": reqData['requestid'], "responsefor":"Update data","responsesetto": reqData['requestsrc'],"responsedata": {"message":"Failed"}}
            return  respfail
    else:
        respfail = {"responseid": reqData['requestid'], "responsefor":"Update data","responsesetto": reqData['requestsrc'],"responsedata": {"message":"Error in Request"}}
        return  respfail

#1.7. Update All
def dborders_processupdateall(req):
     pass



## Functions for dbOrganization
# 1.1. Create
def dborganization_processcreate(reqData):
    if isinstance(reqData, dict):
        #data_to_insert, ids_of_stored = generate_unique_ids('pagename','pagelayoutpropid',reqData, 'pagelayoutnprops')
        #print("all stored ids in db", data_to_insert, ids_of_stored)
        data_to_insert = reqData["requestdata"]
        data=tuple(data_to_insert.values())
        sta=dbilayer.insertIntoDBWithoutCondition('dborganization',constants.column_dborganization_table, data)
        if(sta == "Success"):
            respsucc={"responseid": reqData['requestid'], "responsefor": "Create", "responsesetto": reqData['requestsrc'], "response": {"message": "Success"}}
            return respsucc
        else:
            respfail={"responseid": reqData['requestid'], "responsefor": "Create", "responsesetto": reqData['requestsrc'], "response": {"message": "Some Error in Request"}}
            return respfail
    else:
        respfail={"responseid": reqData['requestid'], "responsefor": "Create", "responsesetto": reqData['requestsrc'], "response": {"message": "Error Encountered"}}
        return respfail


# 1.2. Read One Conditional
def dborganization_processreadonecond(reqData):
    if isinstance(reqData, dict):
        condition_data=reqData['requestdata']
        condition = "dborganizationid = {} AND status = '{}'".format(condition_data["dborganizationid"], condition_data["status"])
        sta=dbilayer.readOneWithcondition('dborganization', '*', condition,tablesdict.dborganization_table)
        print(sta)
        #sta=common.list2dict(sta)
        if (len(sta) >= 1):
            respsucc={"responseid": reqData['requestid'], "responsefor": "Read one", "responsesetto": reqData['requestsrc'], "response": {"message": sta}}
            return respsucc
        else:
            respfail={"responseid": reqData['requestid'], "responsefor": "Read one", "responsesetto": reqData['requestsrc'], "response": {"message": "No data Received!"}}
            return respfail
    else:
        respfail={"responseid": reqData['requestid'], "responsefor": "Read one", "responsesetto": reqData['requestsrc'], "response": {"message": "Error Encountered"}}
        return respfail    


# 1.3. Read Multiple Conditional
def dborganization_processreadmanycond(reqData):
    if isinstance(reqData, dict):
        condition_data=reqData['requestdata']
        condition_data = "status = '{}'".format(condition_data["status"])
        sta=dbilayer.readOneWithcondition('dborganization', '*', condition_data,tablesdict.dborganization_table)
        if (len(sta) >= 1):
            #sta=common.list2dict(sta)
            respsucc={"responseid": reqData['requestid'], "responsefor": "Read all with condition", "responsesetto": reqData['requestsrc'], "response": {"message": sta}}
            return respsucc
        else:
            respfail={"responseid": reqData['requestid'], "responsefor": "Read all with condition", "responsesetto": reqData['requestsrc'], "response":{"message": "No data received!"}}
            return respfail
    else:
        respfail={"responseid": reqData['requestid'], "responsefor": "Read all with condition", "responsesetto": reqData['requestsrc'], "response": {"message": "Error Encountered"}}
        return respfail
    

# 1.4. Read All without condition
def dborganization_processreadmanywithoutcond(reqData):
    if isinstance(reqData, dict):
        if reqData['requestdata']['dborganizationid'] == "all":
            sta=dbilayer.readallWithoutCondition('dborganization', '*',tablesdict.dborganization_table)
            #sta=common.list2dict(sta)
            if (len(sta) >= 1):
                respsucc={"responseid": reqData['requestid'], "responsefor": "Read all", "responsesetto": reqData['requestsrc'], "response": {"message": sta}}
                return respsucc
            else:
                respfail={"responseid": reqData['requestid'], "responsefor": "Read all", "responsesetto": reqData['requestsrc'], "response": {"message": "No data Received!"}}
                return respfail
        else:
            respfail={"responseid": reqData['requestid'], "responsefor": "Read all", "responsesetto": reqData['requestsrc'], "response": {"message": "Some error in request"}}
            return respfail    
    else:
        respfail={"responseid": reqData['requestid'], "responsefor": "Read all", "responsesetto": reqData['requestsrc'], "response": {"message": "Some error in request"}}
        return respfail
    
 #1.5. Delete One Conditional
def dborganization_processdeleteonecond(reqData):
    if reqData['requestdata']['dborganizationid']:
        data = reqData['requestdata']['dborganizationid']
        sta = dbilayer.updateValuesIndb('dborganization',"status ='9'" ,"dborganizationid = {}".format(data))
        print(sta)
        if(sta == "Success"):
            respsucc = {"responseid": reqData['requestid'], "responsefor":"dbOrders_processdeleteonecond","responseto":"UI","responsedata": {"message":"Deleted Successfully"}}
            return  respsucc
        elif(sta == 'Failed'):
            respfail = {"responseid": reqData['requestid'], "responsefor":"dbOrders_processdeleteonecond","responseto":"UI","responsedata": {"message":"Delete request Failed"}}
            return  respfail
    else:
        respfail = {"responseid": reqData['requestid'], "responsefor":"dbOrders_processdeleteonecond","responseto":"UI","responsedata": {"message":"Error in Request"}}
        return  respfail   
    
#1.6. Update One Conditional
def dborganization_processupdateonecond(reqData):
    if isinstance(reqData, dict):
        data=reqData['requestdata']
        dborganizationname = data['dborganizationname']
        dborganizationid=data['dborganizationid']
        dborganizationdesc=data['dborganizationdesc']
        dbpanid=data['dbpanid']
        status = data['status']
        updateStatement = "dborganizationname= '{}',dborganizationdesc='{}',dbpanid= {},status = '{}'".format(dborganizationname,dborganizationdesc,dbpanid,status)
        condition = "dborganizationid = {}".format(dborganizationid)
        sta = dbilayer.updateValuesIndb('dborganization', updateStatement, condition)
        print(sta)
        if(sta == "Success"):
            respsucc = {"responseid": reqData['requestid'], "responsefor":"Update data","responsesetto": reqData['requestsrc'],"responsedata": {"message":"Success"}}
            return  respsucc
        elif(sta == 'Failed'):
            respfail = {"responseid": reqData['requestid'], "responsefor":"Update data","responsesetto": reqData['requestsrc'],"responsedata": {"message":"Failed"}}
            return  respfail
    else:
        respfail = {"responseid": reqData['requestid'], "responsefor":"Update data","responsesetto": reqData['requestsrc'],"responsedata": {"message":"Error in Request"}}
        return  respfail

#1.7. Update All
def dborganization_processupdateall(req):
     pass


## Functions for dbPackage
# 1.1. Create
def dbpackage_processcreate(reqData):
    if isinstance(reqData, dict):
        #data_to_insert, ids_of_stored = generate_unique_ids('pagename','pagelayoutpropid',reqData, 'pagelayoutnprops')
        #print("all stored ids in db", data_to_insert, ids_of_stored)
        data_to_insert = reqData["requestdata"]
        data=tuple(data_to_insert.values())
        sta=dbilayer.insertIntoDBWithoutCondition('dbpackage',constants.column_dbpackage_table, data)
        if(sta == "Success"):
            respsucc={"responseid": reqData['requestid'], "responsefor": "Create", "responsesetto": reqData['requestsrc'], "response": {"message": "Success"}}
            return respsucc
        else:
            respfail={"responseid": reqData['requestid'], "responsefor": "Create", "responsesetto": reqData['requestsrc'], "response": {"message": "Some Error in Request"}}
            return respfail
    else:
        respfail={"responseid": reqData['requestid'], "responsefor": "Create", "responsesetto": reqData['requestsrc'], "response": {"message": "Error Encountered"}}
        return respfail


# 1.2. Read One Conditional
def dbpackage_processreadonecond(reqData):
    if isinstance(reqData, dict):
        condition_data=reqData['requestdata']
        condition = "dbpackageid = {} AND status = '{}'".format(condition_data["dbpackageid"], condition_data["status"])
        sta=dbilayer.readOneWithcondition('dbpackage', '*', condition,tablesdict.dbpackage_table)
        print(sta)
        #sta=common.list2dict(sta)
        if (len(sta) >= 1):
            respsucc={"responseid": reqData['requestid'], "responsefor": "Read one", "responsesetto": reqData['requestsrc'], "response": {"message": sta}}
            return respsucc
        else:
            respfail={"responseid": reqData['requestid'], "responsefor": "Read one", "responsesetto": reqData['requestsrc'], "response": {"message": "No data Received!"}}
            return respfail
    else:
        respfail={"responseid": reqData['requestid'], "responsefor": "Read one", "responsesetto": reqData['requestsrc'], "response": {"message": "Error Encountered"}}
        return respfail    


# 1.3. Read Multiple Conditional
def dbpackage_processreadmanycond(reqData):
    if isinstance(reqData, dict):
        condition_data=reqData['requestdata']
        condition_data = "status = '{}'".format(condition_data["status"])
        sta=dbilayer.readOneWithcondition('dbpackage', '*', condition_data,tablesdict.dbpackage_table)
        if (len(sta) >= 1):
            #sta=common.list2dict(sta)
            respsucc={"responseid": reqData['requestid'], "responsefor": "Read all with condition", "responsesetto": reqData['requestsrc'], "response": {"message": sta}}
            return respsucc
        else:
            respfail={"responseid": reqData['requestid'], "responsefor": "Read all with condition", "responsesetto": reqData['requestsrc'], "response":{"message": "No data received!"}}
            return respfail
    else:
        respfail={"responseid": reqData['requestid'], "responsefor": "Read all with condition", "responsesetto": reqData['requestsrc'], "response": {"message": "Error Encountered"}}
        return respfail
    

# 1.4. Read All without condition
def dbpackage_processreadmanywithoutcond(reqData):
    if isinstance(reqData, dict):
        if reqData['requestdata']['dbpackageid'] == "all":
            sta=dbilayer.readallWithoutCondition('dbpackage', '*',tablesdict.dbpackage_table)
            #sta=common.list2dict(sta)
            if (len(sta) >= 1):
                respsucc={"responseid": reqData['requestid'], "responsefor": "Read all", "responsesetto": reqData['requestsrc'], "response": {"message": sta}}
                return respsucc
            else:
                respfail={"responseid": reqData['requestid'], "responsefor": "Read all", "responsesetto": reqData['requestsrc'], "response": {"message": "No data Received!"}}
                return respfail
        else:
            respfail={"responseid": reqData['requestid'], "responsefor": "Read all", "responsesetto": reqData['requestsrc'], "response": {"message": "Some error in request"}}
            return respfail    
    else:
        respfail={"responseid": reqData['requestid'], "responsefor": "Read all", "responsesetto": reqData['requestsrc'], "response": {"message": "Some error in request"}}
        return respfail
    
 #1.5. Delete One Conditional
def dbpackage_processdeleteonecond(reqData):
    if reqData['requestdata']['dbpackageid']:
        data = reqData['requestdata']['dbpackageid']
        sta = dbilayer.updateValuesIndb('dbpackage',"status ='9'" ,"dbpackageid = {}".format(data))
        print(sta)
        if(sta == "Success"):
            respsucc = {"responseid": reqData['requestid'], "responsefor":"dbPackage_processdeleteonecond","responseto":"UI","responsedata": {"message":"Deleted Successfully"}}
            return  respsucc
        elif(sta == 'Failed'):
            respfail = {"responseid": reqData['requestid'], "responsefor":"dbPackage_processdeleteonecond","responseto":"UI","responsedata": {"message":"Delete request Failed"}}
            return  respfail
    else:
        respfail = {"responseid": reqData['requestid'], "responsefor":"dbPackage_processdeleteonecond","responseto":"UI","responsedata": {"message":"Error in Request"}}
        return  respfail   
    
#1.6. Update One Conditional
def dbpackage_processupdateonecond(reqData):
    if isinstance(reqData, dict):
        data=reqData['requestdata']
        dbpackagename = data['dbpackagename']
        dbpackageid=data['dbpackageid']
        status = data['status']
        updateStatement = "dbpackagename= '{}',status = '{}'".format(dbpackagename,status)
        condition = "dbpackageid = {}".format(dbpackageid)
        sta = dbilayer.updateValuesIndb('dbpackage', updateStatement, condition)
        print(sta)
        if(sta == "Success"):
            respsucc = {"responseid": reqData['requestid'], "responsefor":"Update data","responsesetto": reqData['requestsrc'],"responsedata": {"message":"Success"}}
            return  respsucc
        elif(sta == 'Failed'):
            respfail = {"responseid": reqData['requestid'], "responsefor":"Update data","responsesetto": reqData['requestsrc'],"responsedata": {"message":"Failed"}}
            return  respfail
    else:
        respfail = {"responseid": reqData['requestid'], "responsefor":"Update data","responsesetto": reqData['requestsrc'],"responsedata": {"message":"Error in Request"}}
        return  respfail

#1.7. Update All
def dbpackage_processupdateall(req):
     pass



## Functions for dbPan
# 1.1. Create
def dbpan_processcreate(reqData):
    if isinstance(reqData, dict):
        #data_to_insert, ids_of_stored = generate_unique_ids('pagename','pagelayoutpropid',reqData, 'pagelayoutnprops')
        #print("all stored ids in db", data_to_insert, ids_of_stored)
        data_to_insert = reqData["requestdata"]
        data=tuple(data_to_insert.values())
        sta=dbilayer.insertIntoDBWithoutCondition('dbpan',constants.column_dbpan_table, data)
        if(sta == "Success"):
            respsucc={"responseid": reqData['requestid'], "responsefor": "Create", "responsesetto": reqData['requestsrc'], "response": {"message": "Success"}}
            return respsucc
        else:
            respfail={"responseid": reqData['requestid'], "responsefor": "Create", "responsesetto": reqData['requestsrc'], "response": {"message": "Some Error in Request"}}
            return respfail
    else:
        respfail={"responseid": reqData['requestid'], "responsefor": "Create", "responsesetto": reqData['requestsrc'], "response": {"message": "Error Encountered"}}
        return respfail


# 1.2. Read One Conditional
def dbpan_processreadonecond(reqData):
    if isinstance(reqData, dict):
        condition_data=reqData['requestdata']
        condition = "dbpanid = {} AND status = '{}'".format(condition_data["dbpanid"], condition_data["status"])
        sta=dbilayer.readOneWithcondition('dbpan', '*', condition,tablesdict.dbpan_table)
        print(sta)
        #sta=common.list2dict(sta)
        if (len(sta) >= 1):
            respsucc={"responseid": reqData['requestid'], "responsefor": "Read one", "responsesetto": reqData['requestsrc'], "response": {"message": sta}}
            return respsucc
        else:
            respfail={"responseid": reqData['requestid'], "responsefor": "Read one", "responsesetto": reqData['requestsrc'], "response": {"message": "No data Received!"}}
            return respfail
    else:
        respfail={"responseid": reqData['requestid'], "responsefor": "Read one", "responsesetto": reqData['requestsrc'], "response": {"message": "Error Encountered"}}
        return respfail    


# 1.3. Read Multiple Conditional
def dbpan_processreadmanycond(reqData):
    if isinstance(reqData, dict):
        condition_data=reqData['requestdata']
        condition_data = "status = '{}'".format(condition_data["status"])
        sta=dbilayer.readOneWithcondition('dbpan', '*', condition_data,tablesdict.dbpan_table)
        if (len(sta) >= 1):
            #sta=common.list2dict(sta)
            respsucc={"responseid": reqData['requestid'], "responsefor": "Read all with condition", "responsesetto": reqData['requestsrc'], "response": {"message": sta}}
            return respsucc
        else:
            respfail={"responseid": reqData['requestid'], "responsefor": "Read all with condition", "responsesetto": reqData['requestsrc'], "response":{"message": "No data received!"}}
            return respfail
    else:
        respfail={"responseid": reqData['requestid'], "responsefor": "Read all with condition", "responsesetto": reqData['requestsrc'], "response": {"message": "Error Encountered"}}
        return respfail
    

# 1.4. Read All without condition
def dbpan_processreadmanywithoutcond(reqData):
    if isinstance(reqData, dict):
        if reqData['requestdata']['dbpanid'] == "all":
            sta=dbilayer.readallWithoutCondition('dbpan', '*',tablesdict.dbpan_table)
            #sta=common.list2dict(sta)
            if (len(sta) >= 1):
                respsucc={"responseid": reqData['requestid'], "responsefor": "Read all", "responsesetto": reqData['requestsrc'], "response": {"message": sta}}
                return respsucc
            else:
                respfail={"responseid": reqData['requestid'], "responsefor": "Read all", "responsesetto": reqData['requestsrc'], "response": {"message": "No data Received!"}}
                return respfail
        else:
            respfail={"responseid": reqData['requestid'], "responsefor": "Read all", "responsesetto": reqData['requestsrc'], "response": {"message": "Some error in request"}}
            return respfail    
    else:
        respfail={"responseid": reqData['requestid'], "responsefor": "Read all", "responsesetto": reqData['requestsrc'], "response": {"message": "Some error in request"}}
        return respfail
    
 #1.5. Delete One Conditional
def dbpan_processdeleteonecond(reqData):
    if reqData['requestdata']['dbpanid']:
        data = reqData['requestdata']['dbpanid']
        sta = dbilayer.updateValuesIndb('dbpan',"status ='9'" ,"dbpanid = {}".format(data))
        print(sta)
        if(sta == "Success"):
            respsucc = {"responseid": reqData['requestid'], "responsefor":"dbPAN_processdeleteonecond","responseto":"UI","responsedata": {"message":"Deleted Successfully"}}
            return  respsucc
        elif(sta == 'Failed'):
            respfail = {"responseid": reqData['requestid'], "responsefor":"dbPAN_processdeleteonecond","responseto":"UI","responsedata": {"message":"Delete request Failed"}}
            return  respfail
    else:
        respfail = {"responseid": reqData['requestid'], "responsefor":"dbPAN_processdeleteonecond","responseto":"UI","responsedata": {"message":"Error in Request"}}
        return  respfail   
    
#1.6. Update One Conditional
def dbpan_processupdateonecond(reqData):
    if isinstance(reqData, dict):
        data=reqData['requestdata']
        dbpannumber = data['dbpannumber']
        dbpanid=data['dbpanid']
        dbemailid=data['dbemailid']
        dbphoneid=data['dbphoneid']
        dbkycid=data['dbkycid']
        status = data['status']
        updateStatement = "dbpannumber= '{}',dbemailid= {},dbphoneid= {},dbkycid= {},status = '{}'".format(dbpannumber,dbemailid,dbphoneid,dbkycid,status)
        condition = "dbpanid = {}".format(dbpanid)
        sta = dbilayer.updateValuesIndb('dbpan', updateStatement, condition)
        print(sta)
        if(sta == "Success"):
            respsucc = {"responseid": reqData['requestid'], "responsefor":"Update data","responsesetto": reqData['requestsrc'],"responsedata": {"message":"Success"}}
            return  respsucc
        elif(sta == 'Failed'):
            respfail = {"responseid": reqData['requestid'], "responsefor":"Update data","responsesetto": reqData['requestsrc'],"responsedata": {"message":"Failed"}}
            return  respfail
    else:
        respfail = {"responseid": reqData['requestid'], "responsefor":"Update data","responsesetto": reqData['requestsrc'],"responsedata": {"message":"Error in Request"}}
        return  respfail

#1.7. Update All
def dbpan_processupdateall(req):
     pass



## Functions for dbPassword
# 1.1. Create
def dbpassword_processcreate(reqData):
    if isinstance(reqData, dict):
        #data_to_insert, ids_of_stored = generate_unique_ids('pagename','pagelayoutpropid',reqData, 'pagelayoutnprops')
        #print("all stored ids in db", data_to_insert, ids_of_stored)
        data_to_insert = reqData["requestdata"]
        data=tuple(data_to_insert.values())
        sta=dbilayer.insertIntoDBWithoutCondition('dbpassword',constants.column_dbpassword_table, data)
        if(sta == "Success"):
            respsucc={"responseid": reqData['requestid'], "responsefor": "Create", "responsesetto": reqData['requestsrc'], "response": {"message": "Success"}}
            return respsucc
        else:
            respfail={"responseid": reqData['requestid'], "responsefor": "Create", "responsesetto": reqData['requestsrc'], "response": {"message": "Some Error in Request"}}
            return respfail
    else:
        respfail={"responseid": reqData['requestid'], "responsefor": "Create", "responsesetto": reqData['requestsrc'], "response": {"message": "Error Encountered"}}
        return respfail


# 1.2. Read One Conditional
def dbpassword_processreadonecond(reqData):
    if isinstance(reqData, dict):
        condition_data=reqData['requestdata']
        condition = "dbpasswordid = {} AND status = '{}'".format(condition_data["dbpasswordid"], condition_data["status"])
        sta=dbilayer.readOneWithcondition('dbpassword', '*', condition,tablesdict.dbpassword_table)
        print(sta)
        #sta=common.list2dict(sta)
        if (len(sta) >= 1):
            respsucc={"responseid": reqData['requestid'], "responsefor": "Read one", "responsesetto": reqData['requestsrc'], "response": {"message": sta}}
            return respsucc
        else:
            respfail={"responseid": reqData['requestid'], "responsefor": "Read one", "responsesetto": reqData['requestsrc'], "response": {"message": "No data Received!"}}
            return respfail
    else:
        respfail={"responseid": reqData['requestid'], "responsefor": "Read one", "responsesetto": reqData['requestsrc'], "response": {"message": "Error Encountered"}}
        return respfail    


# 1.3. Read Multiple Conditional
def dbpassword_processreadmanycond(reqData):
    if isinstance(reqData, dict):
        condition_data=reqData['requestdata']
        condition_data = "status = '{}'".format(condition_data["status"])
        sta=dbilayer.readOneWithcondition('dbpassword', '*', condition_data,tablesdict.dbpassword_table)
        if (len(sta) >= 1):
            #sta=common.list2dict(sta)
            respsucc={"responseid": reqData['requestid'], "responsefor": "Read all with condition", "responsesetto": reqData['requestsrc'], "response": {"message": sta}}
            return respsucc
        else:
            respfail={"responseid": reqData['requestid'], "responsefor": "Read all with condition", "responsesetto": reqData['requestsrc'], "response":{"message": "No data received!"}}
            return respfail
    else:
        respfail={"responseid": reqData['requestid'], "responsefor": "Read all with condition", "responsesetto": reqData['requestsrc'], "response": {"message": "Error Encountered"}}
        return respfail
    

# 1.4. Read All without condition
def dbpassword_processreadmanywithoutcond(reqData):
    if isinstance(reqData, dict):
        if reqData['requestdata']['dbpasswordid'] == "all":
            sta=dbilayer.readallWithoutCondition('dbpassword', '*',tablesdict.dbpassword_table)
            #sta=common.list2dict(sta)
            if (len(sta) >= 1):
                respsucc={"responseid": reqData['requestid'], "responsefor": "Read all", "responsesetto": reqData['requestsrc'], "response": {"message": sta}}
                return respsucc
            else:
                respfail={"responseid": reqData['requestid'], "responsefor": "Read all", "responsesetto": reqData['requestsrc'], "response": {"message": "No data Received!"}}
                return respfail
        else:
            respfail={"responseid": reqData['requestid'], "responsefor": "Read all", "responsesetto": reqData['requestsrc'], "response": {"message": "Some error in request"}}
            return respfail    
    else:
        respfail={"responseid": reqData['requestid'], "responsefor": "Read all", "responsesetto": reqData['requestsrc'], "response": {"message": "Some error in request"}}
        return respfail
    
 #1.5. Delete One Conditional
def dbpassword_processdeleteonecond(reqData):
    if reqData['requestdata']['dbpasswordid']:
        data = reqData['requestdata']['dbpasswordid']
        sta = dbilayer.updateValuesIndb('dbPassword',"status ='9'" ,"dbpasswordid = {}".format(data))
        print(sta)
        if(sta == "Success"):
            respsucc = {"responseid": reqData['requestid'], "responsefor":"dbPassword_processdeleteonecond","responseto":"UI","responsedata": {"message":"Deleted Successfully"}}
            return  respsucc
        elif(sta == 'Failed'):
            respfail = {"responseid": reqData['requestid'], "responsefor":"dbPassword_processdeleteonecond","responseto":"UI","responsedata": {"message":"Delete request Failed"}}
            return  respfail
    else:
        respfail = {"responseid": reqData['requestid'], "responsefor":"dbPassword_processdeleteonecond","responseto":"UI","responsedata": {"message":"Error in Request"}}
        return  respfail   
    
#1.6. Update One Conditional
def dbpassword_processupdateonecond(reqData):
    if isinstance(reqData, dict):
        data=reqData['requestdata']
        dbpassword = data['dbpassword']
        dbpasswordid=data['dbpasswordid']
        dbpassworddesc=data['dbpassworddesc']
        dbusernameid=data['dbusernameid']
        dbcategoryid=data['dbcategoryid']
        status = data['status']
        updateStatement = "dbpassword= '{}',dbpassworddesc= '{}',dbusernameid= {},dbcategoryid= {},status = '{}'".format(dbpassword,dbpassworddesc,dbusernameid,dbcategoryid,status)
        condition = "dbpasswordid = {}".format(dbpasswordid)
        sta = dbilayer.updateValuesIndb('dbpassword', updateStatement, condition)
        print(sta)
        if(sta == "Success"):
            respsucc = {"responseid": reqData['requestid'], "responsefor":"Update data","responsesetto": reqData['requestsrc'],"responsedata": {"message":"Success"}}
            return  respsucc
        elif(sta == 'Failed'):
            respfail = {"responseid": reqData['requestid'], "responsefor":"Update data","responsesetto": reqData['requestsrc'],"responsedata": {"message":"Failed"}}
            return  respfail
    else:
        respfail = {"responseid": reqData['requestid'], "responsefor":"Update data","responsesetto": reqData['requestsrc'],"responsedata": {"message":"Error in Request"}}
        return  respfail

#1.7. Update All
def dbpassword_processupdateall(req):
     pass



## Functions for dbPermission
# 1.1. Create
def dbpermission_processcreate(reqData):
    if isinstance(reqData, dict):
        #data_to_insert, ids_of_stored = generate_unique_ids('pagename','pagelayoutpropid',reqData, 'pagelayoutnprops')
        #print("all stored ids in db", data_to_insert, ids_of_stored)
        data_to_insert = reqData["requestdata"]
        data=tuple(data_to_insert.values())
        sta=dbilayer.insertIntoDBWithoutCondition('dbpermission',constants.column_dbpermission_table, data)
        if(sta == "Success"):
            respsucc={"responseid": reqData['requestid'], "responsefor": "Create", "responsesetto": reqData['requestsrc'], "response": {"message": "Success"}}
            return respsucc
        else:
            respfail={"responseid": reqData['requestid'], "responsefor": "Create", "responsesetto": reqData['requestsrc'], "response": {"message": "Some Error in Request"}}
            return respfail
    else:
        respfail={"responseid": reqData['requestid'], "responsefor": "Create", "responsesetto": reqData['requestsrc'], "response": {"message": "Error Encountered"}}
        return respfail


# 1.2. Read One Conditional
def dbpermission_processreadonecond(reqData):
    if isinstance(reqData, dict):
        condition_data=reqData['requestdata']
        condition = "dbpermissionid = {} AND status = '{}'".format(condition_data["dbpermissionid"], condition_data["status"])
        sta=dbilayer.readOneWithcondition('dbpermission', '*', condition,tablesdict.dbpermission_table)
        print(sta)
        #sta=common.list2dict(sta)
        if (len(sta) >= 1):
            respsucc={"responseid": reqData['requestid'], "responsefor": "Read one", "responsesetto": reqData['requestsrc'], "response": {"message": sta}}
            return respsucc
        else:
            respfail={"responseid": reqData['requestid'], "responsefor": "Read one", "responsesetto": reqData['requestsrc'], "response": {"message": "No data Received!"}}
            return respfail
    else:
        respfail={"responseid": reqData['requestid'], "responsefor": "Read one", "responsesetto": reqData['requestsrc'], "response": {"message": "Error Encountered"}}
        return respfail    


# 1.3. Read Multiple Conditional
def dbpermission_processreadmanycond(reqData):
    if isinstance(reqData, dict):
        condition_data=reqData['requestdata']
        condition_data = "status = '{}'".format(condition_data["status"])
        sta=dbilayer.readOneWithcondition('dbpermission', '*', condition_data,tablesdict.dbpermission_table)
        if (len(sta) >= 1):
            #sta=common.list2dict(sta)
            respsucc={"responseid": reqData['requestid'], "responsefor": "Read all with condition", "responsesetto": reqData['requestsrc'], "response": {"message": sta}}
            return respsucc
        else:
            respfail={"responseid": reqData['requestid'], "responsefor": "Read all with condition", "responsesetto": reqData['requestsrc'], "response":{"message": "No data received!"}}
            return respfail
    else:
        respfail={"responseid": reqData['requestid'], "responsefor": "Read all with condition", "responsesetto": reqData['requestsrc'], "response": {"message": "Error Encountered"}}
        return respfail
    

# 1.4. Read All without condition
def dbpermission_processreadmanywithoutcond(reqData):
    if isinstance(reqData, dict):
        if reqData['requestdata']['dbpermissionid'] == "all":
            sta=dbilayer.readallWithoutCondition('dbpermission', '*',tablesdict.dbpermission_table)
            #sta=common.list2dict(sta)
            if (len(sta) >= 1):
                respsucc={"responseid": reqData['requestid'], "responsefor": "Read all", "responsesetto": reqData['requestsrc'], "response": {"message": sta}}
                return respsucc
            else:
                respfail={"responseid": reqData['requestid'], "responsefor": "Read all", "responsesetto": reqData['requestsrc'], "response": {"message": "No data Received!"}}
                return respfail
        else:
            respfail={"responseid": reqData['requestid'], "responsefor": "Read all", "responsesetto": reqData['requestsrc'], "response": {"message": "Some error in request"}}
            return respfail    
    else:
        respfail={"responseid": reqData['requestid'], "responsefor": "Read all", "responsesetto": reqData['requestsrc'], "response": {"message": "Some error in request"}}
        return respfail
    
 #1.5. Delete One Conditional
def dbpermission_processdeleteonecond(reqData):
    if reqData['requestdata']['dbpermissionid']:
        data = reqData['requestdata']['dbpermissionid']
        sta = dbilayer.updateValuesIndb('dbPermission',"status ='9'" ,"dbpermissionid = {}".format(data))
        print(sta)
        if(sta == "Success"):
            respsucc = {"responseid": reqData['requestid'], "responsefor":"dbPermission_processdeleteonecond","responseto":"UI","responsedata": {"message":"Deleted Successfully"}}
            return  respsucc
        elif(sta == 'Failed'):
            respfail = {"responseid": reqData['requestid'], "responsefor":"dbPermission_processdeleteonecond","responseto":"UI","responsedata": {"message":"Delete request Failed"}}
            return  respfail
    else:
        respfail = {"responseid": reqData['requestid'], "responsefor":"dbPermission_processdeleteonecond","responseto":"UI","responsedata": {"message":"Error in Request"}}
        return  respfail   
    
#1.6. Update One Conditional
def dbpermission_processupdateonecond(reqData):
    if isinstance(reqData, dict):
        data=reqData['requestdata']
        dbpermissionname = data['dbpermissionname']
        dbpermissionid=data['dbpermissionid']
        dbtypeid=data['dbtypeid']
        dbaclid=data['dbaclid']
        status = data['status']
        updateStatement = "dbpermissionname= '{}',dbtypeid= {},dbaclid= {},status = '{}'".format(dbpermissionname,dbtypeid,dbaclid,status)
        condition = "dbpermissionid = {}".format(dbpermissionid)
        sta = dbilayer.updateValuesIndb('dbpermission', updateStatement, condition)
        print(sta)
        if(sta == "Success"):
            respsucc = {"responseid": reqData['requestid'], "responsefor":"Update data","responsesetto": reqData['requestsrc'],"responsedata": {"message":"Success"}}
            return  respsucc
        elif(sta == 'Failed'):
            respfail = {"responseid": reqData['requestid'], "responsefor":"Update data","responsesetto": reqData['requestsrc'],"responsedata": {"message":"Failed"}}
            return  respfail
    else:
        respfail = {"responseid": reqData['requestid'], "responsefor":"Update data","responsesetto": reqData['requestsrc'],"responsedata": {"message":"Error in Request"}}
        return  respfail

#1.7. Update All
def dbpermission_processupdateall(req):
     pass



## Functions for dbPhone
# 1.1. Create
def dbphone_processcreate(reqData):
    if isinstance(reqData, dict):
        #data_to_insert, ids_of_stored = generate_unique_ids('pagename','pagelayoutpropid',reqData, 'pagelayoutnprops')
        #print("all stored ids in db", data_to_insert, ids_of_stored)
        data_to_insert = reqData["requestdata"]
        data=tuple(data_to_insert.values())
        sta=dbilayer.insertIntoDBWithoutCondition('dbphone',constants.column_dbphone_table, data)
        if(sta == "Success"):
            respsucc={"responseid": reqData['requestid'], "responsefor": "Create", "responsesetto": reqData['requestsrc'], "response": {"message": "Success"}}
            return respsucc
        else:
            respfail={"responseid": reqData['requestid'], "responsefor": "Create", "responsesetto": reqData['requestsrc'], "response": {"message": "Some Error in Request"}}
            return respfail
    else:
        respfail={"responseid": reqData['requestid'], "responsefor": "Create", "responsesetto": reqData['requestsrc'], "response": {"message": "Error Encountered"}}
        return respfail


# 1.2. Read One Conditional
def dbphone_processreadonecond(reqData):
    if isinstance(reqData, dict):
        condition_data=reqData['requestdata']
        condition = "dbphoneid = {} AND status = '{}'".format(condition_data["dbphoneid"], condition_data["status"])
        sta=dbilayer.readOneWithcondition('dbphone', '*', condition,tablesdict.dbphone_table)
        print(sta)
        #sta=common.list2dict(sta)
        if (len(sta) >= 1):
            respsucc={"responseid": reqData['requestid'], "responsefor": "Read one", "responsesetto": reqData['requestsrc'], "response": {"message": sta}}
            return respsucc
        else:
            respfail={"responseid": reqData['requestid'], "responsefor": "Read one", "responsesetto": reqData['requestsrc'], "response": {"message": "No data Received!"}}
            return respfail
    else:
        respfail={"responseid": reqData['requestid'], "responsefor": "Read one", "responsesetto": reqData['requestsrc'], "response": {"message": "Error Encountered"}}
        return respfail    


# 1.3. Read Multiple Conditional
def dbphone_processreadmanycond(reqData):
    if isinstance(reqData, dict):
        condition_data=reqData['requestdata']
        condition_data = "status = '{}'".format(condition_data["status"])
        sta=dbilayer.readOneWithcondition('dbphone', '*', condition_data,tablesdict.dbphone_table)
        if (len(sta) >= 1):
            #sta=common.list2dict(sta)
            respsucc={"responseid": reqData['requestid'], "responsefor": "Read all with condition", "responsesetto": reqData['requestsrc'], "response": {"message": sta}}
            return respsucc
        else:
            respfail={"responseid": reqData['requestid'], "responsefor": "Read all with condition", "responsesetto": reqData['requestsrc'], "response":{"message": "No data received!"}}
            return respfail
    else:
        respfail={"responseid": reqData['requestid'], "responsefor": "Read all with condition", "responsesetto": reqData['requestsrc'], "response": {"message": "Error Encountered"}}
        return respfail
    

# 1.4. Read All without condition
def dbphone_processreadmanywithoutcond(reqData):
    if isinstance(reqData, dict):
        if reqData['requestdata']['dbphoneid'] == "all":
            sta=dbilayer.readallWithoutCondition('dbphone', '*',tablesdict.dbphone_table)
            #sta=common.list2dict(sta)
            if (len(sta) >= 1):
                respsucc={"responseid": reqData['requestid'], "responsefor": "Read all", "responsesetto": reqData['requestsrc'], "response": {"message": sta}}
                return respsucc
            else:
                respfail={"responseid": reqData['requestid'], "responsefor": "Read all", "responsesetto": reqData['requestsrc'], "response": {"message": "No data Received!"}}
                return respfail
        else:
            respfail={"responseid": reqData['requestid'], "responsefor": "Read all", "responsesetto": reqData['requestsrc'], "response": {"message": "Some error in request"}}
            return respfail    
    else:
        respfail={"responseid": reqData['requestid'], "responsefor": "Read all", "responsesetto": reqData['requestsrc'], "response": {"message": "Some error in request"}}
        return respfail
    
 #1.5. Delete One Conditional
def dbphone_processdeleteonecond(reqData):
    if reqData['requestdata']['dbphoneid']:
        data = reqData['requestdata']['dbphoneid']
        sta = dbilayer.updateValuesIndb('dbphone',"status ='9'" ,"dbphoneid = {}".format(data))
        print(sta)
        if(sta == "Success"):
            respsucc = {"responseid": reqData['requestid'], "responsefor":"dbPhone_processdeleteonecond","responseto":"UI","responsedata": {"message":"Deleted Successfully"}}
            return  respsucc
        elif(sta == 'Failed'):
            respfail = {"responseid": reqData['requestid'], "responsefor":"dbPhone_processdeleteonecond","responseto":"UI","responsedata": {"message":"Delete request Failed"}}
            return  respfail
    else:
        respfail = {"responseid": reqData['requestid'], "responsefor":"dbPhone_processdeleteonecond","responseto":"UI","responsedata": {"message":"Error in Request"}}
        return  respfail   
    
#1.6. Update One Conditional
def dbphone_processupdateonecond(reqData):
    if isinstance(reqData, dict):
        data=reqData['requestdata']
        dbphonenumber = data['dbphonenumber']
        dbphoneid=data['dbphoneid']
        status = data['status']
        updateStatement = "dbphonenumber= '{}',status = '{}'".format(dbphonenumber,status)
        condition = "dbphoneid = {}".format(dbphoneid)
        sta = dbilayer.updateValuesIndb('dbphone', updateStatement, condition)
        print(sta)
        if(sta == "Success"):
            respsucc = {"responseid": reqData['requestid'], "responsefor":"Update data","responsesetto": reqData['requestsrc'],"responsedata": {"message":"Success"}}
            return  respsucc
        elif(sta == 'Failed'):
            respfail = {"responseid": reqData['requestid'], "responsefor":"Update data","responsesetto": reqData['requestsrc'],"responsedata": {"message":"Failed"}}
            return  respfail
    else:
        respfail = {"responseid": reqData['requestid'], "responsefor":"Update data","responsesetto": reqData['requestsrc'],"responsedata": {"message":"Error in Request"}}
        return  respfail

#1.7. Update All
def dbphone_processupdateall(req):
     pass


## Functions for dbPincode
# 1.1. Create
def dbpincode_processcreate(reqData):
    if isinstance(reqData, dict):
        #data_to_insert, ids_of_stored = generate_unique_ids('pagename','pagelayoutpropid',reqData, 'pagelayoutnprops')
        #print("all stored ids in db", data_to_insert, ids_of_stored)
        data_to_insert = reqData["requestdata"]
        data=tuple(data_to_insert.values())
        sta=dbilayer.insertIntoDBWithoutCondition('dbpincode',constants.column_dbpincode_table, data)
        if(sta == "Success"):
            respsucc={"responseid": reqData['requestid'], "responsefor": "Create", "responsesetto": reqData['requestsrc'], "response": {"message": "Success"}}
            return respsucc
        else:
            respfail={"responseid": reqData['requestid'], "responsefor": "Create", "responsesetto": reqData['requestsrc'], "response": {"message": "Some Error in Request"}}
            return respfail
    else:
        respfail={"responseid": reqData['requestid'], "responsefor": "Create", "responsesetto": reqData['requestsrc'], "response": {"message": "Error Encountered"}}
        return respfail


# 1.2. Read One Conditional
def dbpincode_processreadonecond(reqData):
    if isinstance(reqData, dict):
        condition_data=reqData['requestdata']
        condition = "dbpincodeid = {} AND status = '{}'".format(condition_data["dbpincodeid"], condition_data["status"])
        sta=dbilayer.readOneWithcondition('dbpincode', '*', condition,tablesdict.dbpincode_table)
        print(sta)
        #sta=common.list2dict(sta)
        if (len(sta) >= 1):
            respsucc={"responseid": reqData['requestid'], "responsefor": "Read one", "responsesetto": reqData['requestsrc'], "response": {"message": sta}}
            return respsucc
        else:
            respfail={"responseid": reqData['requestid'], "responsefor": "Read one", "responsesetto": reqData['requestsrc'], "response": {"message": "No data Received!"}}
            return respfail
    else:
        respfail={"responseid": reqData['requestid'], "responsefor": "Read one", "responsesetto": reqData['requestsrc'], "response": {"message": "Error Encountered"}}
        return respfail    


# 1.3. Read Multiple Conditional
def dbpincode_processreadmanycond(reqData):
    if isinstance(reqData, dict):
        condition_data=reqData['requestdata']
        condition_data = "status = '{}'".format(condition_data["status"])
        sta=dbilayer.readOneWithcondition('dbpincode', '*', condition_data,tablesdict.dbpincode_table)
        if (len(sta) >= 1):
            #sta=common.list2dict(sta)
            respsucc={"responseid": reqData['requestid'], "responsefor": "Read all with condition", "responsesetto": reqData['requestsrc'], "response": {"message": sta}}
            return respsucc
        else:
            respfail={"responseid": reqData['requestid'], "responsefor": "Read all with condition", "responsesetto": reqData['requestsrc'], "response":{"message": "No data received!"}}
            return respfail
    else:
        respfail={"responseid": reqData['requestid'], "responsefor": "Read all with condition", "responsesetto": reqData['requestsrc'], "response": {"message": "Error Encountered"}}
        return respfail
    

# 1.4. Read All without condition
def dbpincode_processreadmanywithoutcond(reqData):
    if isinstance(reqData, dict):
        if reqData['requestdata']['dbpincodeid'] == "all":
            sta=dbilayer.readallWithoutCondition('dbpincode', '*',tablesdict.dbpincode_table)
            #sta=common.list2dict(sta)
            if (len(sta) >= 1):
                respsucc={"responseid": reqData['requestid'], "responsefor": "Read all", "responsesetto": reqData['requestsrc'], "response": {"message": sta}}
                return respsucc
            else:
                respfail={"responseid": reqData['requestid'], "responsefor": "Read all", "responsesetto": reqData['requestsrc'], "response": {"message": "No data Received!"}}
                return respfail
        else:
            respfail={"responseid": reqData['requestid'], "responsefor": "Read all", "responsesetto": reqData['requestsrc'], "response": {"message": "Some error in request"}}
            return respfail    
    else:
        respfail={"responseid": reqData['requestid'], "responsefor": "Read all", "responsesetto": reqData['requestsrc'], "response": {"message": "Some error in request"}}
        return respfail
    
 #1.5. Delete One Conditional
def dbpincode_processdeleteonecond(reqData):
    if reqData['requestdata']['dbpincodeid']:
        data = reqData['requestdata']['dbpincodeid']
        sta = dbilayer.updateValuesIndb('dbpincode',"status ='9'" ,"dbpincodeid = {}".format(data))
        print(sta)
        if(sta == "Success"):
            respsucc = {"responseid": reqData['requestid'], "responsefor":"dbPincode_processdeleteonecond","responseto":"UI","responsedata": {"message":"Deleted Successfully"}}
            return  respsucc
        elif(sta == 'Failed'):
            respfail = {"responseid": reqData['requestid'], "responsefor":"dbPincode_processdeleteonecond","responseto":"UI","responsedata": {"message":"Delete request Failed"}}
            return  respfail
    else:
        respfail = {"responseid": reqData['requestid'], "responsefor":"dbPincode_processdeleteonecond","responseto":"UI","responsedata": {"message":"Error in Request"}}
        return  respfail   
    
#1.6. Update One Conditional
def dbpincode_processupdateonecond(reqData):
    if isinstance(reqData, dict):
        data=reqData['requestdata']
        dbpincode = data['dbpincode']
        dbpincodeid=data['dbpincodeid']
        dbcityid=data['dbcityid']
        dbstateid=data['dbstateid']
        dbcountryid=data['dbcountryid']
        status = data['status']
        updateStatement = "dbpincode= '{}',dbcityid= {},dbstateid= {},dbcountryid= {},status = '{}'".format(dbpincode,dbcityid,dbstateid,dbcountryid,status)
        condition = "dbpincodeid = {}".format(dbpincodeid)
        sta = dbilayer.updateValuesIndb('dbpincode', updateStatement, condition)
        print(sta)
        if(sta == "Success"):
            respsucc = {"responseid": reqData['requestid'], "responsefor":"Update data","responsesetto": reqData['requestsrc'],"responsedata": {"message":"Success"}}
            return  respsucc
        elif(sta == 'Failed'):
            respfail = {"responseid": reqData['requestid'], "responsefor":"Update data","responsesetto": reqData['requestsrc'],"responsedata": {"message":"Failed"}}
            return  respfail
    else:
        respfail = {"responseid": reqData['requestid'], "responsefor":"Update data","responsesetto": reqData['requestsrc'],"responsedata": {"message":"Error in Request"}}
        return  respfail

#1.7. Update All
def dbpincode_processupdateall(req):
     pass



## Functions for dbPlan
# 1.1. Create
def dbplan_processcreate(reqData):
    if isinstance(reqData, dict):
        #data_to_insert, ids_of_stored = generate_unique_ids('pagename','pagelayoutpropid',reqData, 'pagelayoutnprops')
        #print("all stored ids in db", data_to_insert, ids_of_stored)
        data_to_insert = reqData["requestdata"]
        data=tuple(data_to_insert.values())
        sta=dbilayer.insertIntoDBWithoutCondition('dbplan',constants.column_dbplan_table, data)
        if(sta == "Success"):
            respsucc={"responseid": reqData['requestid'], "responsefor": "Create", "responsesetto": reqData['requestsrc'], "response": {"message": "Success"}}
            return respsucc
        else:
            respfail={"responseid": reqData['requestid'], "responsefor": "Create", "responsesetto": reqData['requestsrc'], "response": {"message": "Some Error in Request"}}
            return respfail
    else:
        respfail={"responseid": reqData['requestid'], "responsefor": "Create", "responsesetto": reqData['requestsrc'], "response": {"message": "Error Encountered"}}
        return respfail


# 1.2. Read One Conditional
def dbplan_processreadonecond(reqData):
    if isinstance(reqData, dict):
        condition_data=reqData['requestdata']
        condition = "dbplanid = {} AND status = '{}'".format(condition_data["dbplanid"], condition_data["status"])
        sta=dbilayer.readOneWithcondition('dbplan', '*', condition,tablesdict.dbplan_table)
        print(sta)
        #sta=common.list2dict(sta)
        if (len(sta) >= 1):
            respsucc={"responseid": reqData['requestid'], "responsefor": "Read one", "responsesetto": reqData['requestsrc'], "response": {"message": sta}}
            return respsucc
        else:
            respfail={"responseid": reqData['requestid'], "responsefor": "Read one", "responsesetto": reqData['requestsrc'], "response": {"message": "No data Received!"}}
            return respfail
    else:
        respfail={"responseid": reqData['requestid'], "responsefor": "Read one", "responsesetto": reqData['requestsrc'], "response": {"message": "Error Encountered"}}
        return respfail    


# 1.3. Read Multiple Conditional
def dbplan_processreadmanycond(reqData):
    if isinstance(reqData, dict):
        condition_data=reqData['requestdata']
        condition_data = "status = '{}'".format(condition_data["status"])
        sta=dbilayer.readOneWithcondition('dbplan', '*', condition_data,tablesdict.dbplan_table)
        if (len(sta) >= 1):
            #sta=common.list2dict(sta)
            respsucc={"responseid": reqData['requestid'], "responsefor": "Read all with condition", "responsesetto": reqData['requestsrc'], "response": {"message": sta}}
            return respsucc
        else:
            respfail={"responseid": reqData['requestid'], "responsefor": "Read all with condition", "responsesetto": reqData['requestsrc'], "response":{"message": "No data received!"}}
            return respfail
    else:
        respfail={"responseid": reqData['requestid'], "responsefor": "Read all with condition", "responsesetto": reqData['requestsrc'], "response": {"message": "Error Encountered"}}
        return respfail
    

# 1.4. Read All without condition
def dbplan_processreadmanywithoutcond(reqData):
    if isinstance(reqData, dict):
        if reqData['requestdata']['dbplanid'] == "all":
            sta=dbilayer.readallWithoutCondition('dbplan', '*',tablesdict.dbplan_table)
            #sta=common.list2dict(sta)
            if (len(sta) >= 1):
                respsucc={"responseid": reqData['requestid'], "responsefor": "Read all", "responsesetto": reqData['requestsrc'], "response": {"message": sta}}
                return respsucc
            else:
                respfail={"responseid": reqData['requestid'], "responsefor": "Read all", "responsesetto": reqData['requestsrc'], "response": {"message": "No data Received!"}}
                return respfail
        else:
            respfail={"responseid": reqData['requestid'], "responsefor": "Read all", "responsesetto": reqData['requestsrc'], "response": {"message": "Some error in request"}}
            return respfail    
    else:
        respfail={"responseid": reqData['requestid'], "responsefor": "Read all", "responsesetto": reqData['requestsrc'], "response": {"message": "Some error in request"}}
        return respfail
    
 #1.5. Delete One Conditional
def dbplan_processdeleteonecond(reqData):
    if reqData['requestdata']['dbplanid']:
        data = reqData['requestdata']['dbplanid']
        sta = dbilayer.updateValuesIndb('dbplan',"status ='9'" ,"dbplanid = {}".format(data))
        print(sta)
        if(sta == "Success"):
            respsucc = {"responseid": reqData['requestid'], "responsefor":"dbPincode_processdeleteonecond","responseto":"UI","responsedata": {"message":"Deleted Successfully"}}
            return  respsucc
        elif(sta == 'Failed'):
            respfail = {"responseid": reqData['requestid'], "responsefor":"dbPincode_processdeleteonecond","responseto":"UI","responsedata": {"message":"Delete request Failed"}}
            return  respfail
    else:
        respfail = {"responseid": reqData['requestid'], "responsefor":"dbPincode_processdeleteonecond","responseto":"UI","responsedata": {"message":"Error in Request"}}
        return  respfail   
    
#1.6. Update One Conditional
def dbplan_processupdateonecond(reqData):
    if isinstance(reqData, dict):
        data=reqData['requestdata']
        dbplanname = data['dbplanname']
        dbplanid=data['dbplanid']
        status = data['status']
        updateStatement = "dbplanname= '{}',status = '{}'".format(dbplanname,status)
        condition = "dbplanid = {}".format(dbplanid)
        sta = dbilayer.updateValuesIndb('dbplan', updateStatement, condition)
        print(sta)
        if(sta == "Success"):
            respsucc = {"responseid": reqData['requestid'], "responsefor":"Update data","responsesetto": reqData['requestsrc'],"responsedata": {"message":"Success"}}
            return  respsucc
        elif(sta == 'Failed'):
            respfail = {"responseid": reqData['requestid'], "responsefor":"Update data","responsesetto": reqData['requestsrc'],"responsedata": {"message":"Failed"}}
            return  respfail
    else:
        respfail = {"responseid": reqData['requestid'], "responsefor":"Update data","responsesetto": reqData['requestsrc'],"responsedata": {"message":"Error in Request"}}
        return  respfail

#1.7. Update All
def dbplan_processupdateall(req):
     pass


## Functions for dbPlanBilling
# 1.1. Create
def dbplanbilling_processcreate(reqData):
    if isinstance(reqData, dict):
        #data_to_insert, ids_of_stored = generate_unique_ids('pagename','pagelayoutpropid',reqData, 'pagelayoutnprops')
        #print("all stored ids in db", data_to_insert, ids_of_stored)
        data_to_insert = reqData["requestdata"]
        data=tuple(data_to_insert.values())
        sta=dbilayer.insertIntoDBWithoutCondition('dbplanbilling',constants.column_dbplanbilling_table, data)
        if(sta == "Success"):
            respsucc={"responseid": reqData['requestid'], "responsefor": "Create", "responsesetto": reqData['requestsrc'], "response": {"message": "Success"}}
            return respsucc
        else:
            respfail={"responseid": reqData['requestid'], "responsefor": "Create", "responsesetto": reqData['requestsrc'], "response": {"message": "Some Error in Request"}}
            return respfail
    else:
        respfail={"responseid": reqData['requestid'], "responsefor": "Create", "responsesetto": reqData['requestsrc'], "response": {"message": "Error Encountered"}}
        return respfail


# 1.2. Read One Conditional
def dbplanbilling_processreadonecond(reqData):
    if isinstance(reqData, dict):
        condition_data=reqData['requestdata']
        condition = "dbplanbillingid = {} AND status = '{}'".format(condition_data["dbplanbillingid"], condition_data["status"])
        sta=dbilayer.readOneWithcondition('dbplanbilling', '*', condition,tablesdict.dbplanbilling_table)
        print(sta)
        #sta=common.list2dict(sta)
        if (len(sta) >= 1):
            respsucc={"responseid": reqData['requestid'], "responsefor": "Read one", "responsesetto": reqData['requestsrc'], "response": {"message": sta}}
            return respsucc
        else:
            respfail={"responseid": reqData['requestid'], "responsefor": "Read one", "responsesetto": reqData['requestsrc'], "response": {"message": "No data Received!"}}
            return respfail
    else:
        respfail={"responseid": reqData['requestid'], "responsefor": "Read one", "responsesetto": reqData['requestsrc'], "response": {"message": "Error Encountered"}}
        return respfail    


# 1.3. Read Multiple Conditional
def dbplanbilling_processreadmanycond(reqData):
    if isinstance(reqData, dict):
        condition_data=reqData['requestdata']
        condition_data = "status = '{}'".format(condition_data["status"])
        sta=dbilayer.readOneWithcondition('dbplanbilling', '*', condition_data,tablesdict.dbplanbilling_table)
        if (len(sta) >= 1):
            #sta=common.list2dict(sta)
            respsucc={"responseid": reqData['requestid'], "responsefor": "Read all with condition", "responsesetto": reqData['requestsrc'], "response": {"message": sta}}
            return respsucc
        else:
            respfail={"responseid": reqData['requestid'], "responsefor": "Read all with condition", "responsesetto": reqData['requestsrc'], "response":{"message": "No data received!"}}
            return respfail
    else:
        respfail={"responseid": reqData['requestid'], "responsefor": "Read all with condition", "responsesetto": reqData['requestsrc'], "response": {"message": "Error Encountered"}}
        return respfail
    

# 1.4. Read All without condition
def dbplanbilling_processreadmanywithoutcond(reqData):
    if isinstance(reqData, dict):
        if reqData['requestdata']['dbplanbillingid'] == "all":
            sta=dbilayer.readallWithoutCondition('dbplanbilling', '*',tablesdict.dbplanbilling_table)
            #sta=common.list2dict(sta)
            if (len(sta) >= 1):
                respsucc={"responseid": reqData['requestid'], "responsefor": "Read all", "responsesetto": reqData['requestsrc'], "response": {"message": sta}}
                return respsucc
            else:
                respfail={"responseid": reqData['requestid'], "responsefor": "Read all", "responsesetto": reqData['requestsrc'], "response": {"message": "No data Received!"}}
                return respfail
        else:
            respfail={"responseid": reqData['requestid'], "responsefor": "Read all", "responsesetto": reqData['requestsrc'], "response": {"message": "Some error in request"}}
            return respfail    
    else:
        respfail={"responseid": reqData['requestid'], "responsefor": "Read all", "responsesetto": reqData['requestsrc'], "response": {"message": "Some error in request"}}
        return respfail
    
 #1.5. Delete One Conditional
def dbplanbilling_processdeleteonecond(reqData):
    if reqData['requestdata']['dbplanbillingid']:
        data = reqData['requestdata']['dbplanbillingid']
        sta = dbilayer.updateValuesIndb('dbplanbilling',"status ='9'" ,"dbplanbillingid = {}".format(data))
        print(sta)
        if(sta == "Success"):
            respsucc = {"responseid": reqData['requestid'], "responsefor":"dbPlanBilling_processdeleteonecond","responseto":"UI","responsedata": {"message":"Deleted Successfully"}}
            return  respsucc
        elif(sta == 'Failed'):
            respfail = {"responseid": reqData['requestid'], "responsefor":"dbPlanBilling_processdeleteonecond","responseto":"UI","responsedata": {"message":"Delete request Failed"}}
            return  respfail
    else:
        respfail = {"responseid": reqData['requestid'], "responsefor":"dbPlanBilling_processdeleteonecond","responseto":"UI","responsedata": {"message":"Error in Request"}}
        return  respfail   
    
#1.6. Update One Conditional
def dbplanbilling_processupdateonecond(reqData):
    if isinstance(reqData, dict):
        data=reqData['requestdata']
        dbplanbillingname = data['dbplanbillingname']
        dbplanbillingid=data['dbplanbillingid']
        dbpackageid=data['dbpackageid']
        dbplanid=data['dbplanid']
        status = data['status']
        updateStatement = "dbplanbillingname= '{}',dbpackageid= {},dbplanid= {},status = '{}'".format(dbplanbillingname,dbpackageid,dbplanid,status)
        condition = "dbplanbillingid = {}".format(dbplanbillingid)
        sta = dbilayer.updateValuesIndb('dbplanbilling', updateStatement, condition)
        print(sta)
        if(sta == "Success"):
            respsucc = {"responseid": reqData['requestid'], "responsefor":"Update data","responsesetto": reqData['requestsrc'],"responsedata": {"message":"Success"}}
            return  respsucc
        elif(sta == 'Failed'):
            respfail = {"responseid": reqData['requestid'], "responsefor":"Update data","responsesetto": reqData['requestsrc'],"responsedata": {"message":"Failed"}}
            return  respfail
    else:
        respfail = {"responseid": reqData['requestid'], "responsefor":"Update data","responsesetto": reqData['requestsrc'],"responsedata": {"message":"Error in Request"}}
        return  respfail

#1.7. Update All
def dbplanbilling_processupdateall(req):
     pass



## Functions for dbPlans
# 1.1. Create
def dbplans_processcreate(reqData):
    if isinstance(reqData, dict):
        #data_to_insert, ids_of_stored = generate_unique_ids('pagename','pagelayoutpropid',reqData, 'pagelayoutnprops')
        #print("all stored ids in db", data_to_insert, ids_of_stored)
        data_to_insert = reqData["requestdata"]
        data=tuple(data_to_insert.values())
        sta=dbilayer.insertIntoDBWithoutCondition('dbplans',constants.column_dbplans_table, data)
        if(sta == "Success"):
            respsucc={"responseid": reqData['requestid'], "responsefor": "Create", "responsesetto": reqData['requestsrc'], "response": {"message": "Success"}}
            return respsucc
        else:
            respfail={"responseid": reqData['requestid'], "responsefor": "Create", "responsesetto": reqData['requestsrc'], "response": {"message": "Some Error in Request"}}
            return respfail
    else:
        respfail={"responseid": reqData['requestid'], "responsefor": "Create", "responsesetto": reqData['requestsrc'], "response": {"message": "Error Encountered"}}
        return respfail


# 1.2. Read One Conditional
def dbplans_processreadonecond(reqData):
    if isinstance(reqData, dict):
        condition_data=reqData['requestdata']
        condition = "dbplansid = {} AND status = '{}'".format(condition_data["dbplansid"], condition_data["status"])
        sta=dbilayer.readOneWithcondition('dbplans', '*', condition,tablesdict.dbplans_table)
        print(sta)
        #sta=common.list2dict(sta)
        if (len(sta) >= 1):
            respsucc={"responseid": reqData['requestid'], "responsefor": "Read one", "responsesetto": reqData['requestsrc'], "response": {"message": sta}}
            return respsucc
        else:
            respfail={"responseid": reqData['requestid'], "responsefor": "Read one", "responsesetto": reqData['requestsrc'], "response": {"message": "No data Received!"}}
            return respfail
    else:
        respfail={"responseid": reqData['requestid'], "responsefor": "Read one", "responsesetto": reqData['requestsrc'], "response": {"message": "Error Encountered"}}
        return respfail    


# 1.3. Read Multiple Conditional
def dbplans_processreadmanycond(reqData):
    if isinstance(reqData, dict):
        condition_data=reqData['requestdata']
        condition_data = "status = '{}'".format(condition_data["status"])
        sta=dbilayer.readOneWithcondition('dbplans', '*', condition_data,tablesdict.dbplans_table)
        if (len(sta) >= 1):
            #sta=common.list2dict(sta)
            respsucc={"responseid": reqData['requestid'], "responsefor": "Read all with condition", "responsesetto": reqData['requestsrc'], "response": {"message": sta}}
            return respsucc
        else:
            respfail={"responseid": reqData['requestid'], "responsefor": "Read all with condition", "responsesetto": reqData['requestsrc'], "response":{"message": "No data received!"}}
            return respfail
    else:
        respfail={"responseid": reqData['requestid'], "responsefor": "Read all with condition", "responsesetto": reqData['requestsrc'], "response": {"message": "Error Encountered"}}
        return respfail
    

# 1.4. Read All without condition
def dbplans_processreadmanywithoutcond(reqData):
    if isinstance(reqData, dict):
        if reqData['requestdata']['dbplansid'] == "all":
            sta=dbilayer.readallWithoutCondition('dbplans', '*',tablesdict.dbplans_table)
            #sta=common.list2dict(sta)
            if (len(sta) >= 1):
                respsucc={"responseid": reqData['requestid'], "responsefor": "Read all", "responsesetto": reqData['requestsrc'], "response": {"message": sta}}
                return respsucc
            else:
                respfail={"responseid": reqData['requestid'], "responsefor": "Read all", "responsesetto": reqData['requestsrc'], "response": {"message": "No data Received!"}}
                return respfail
        else:
            respfail={"responseid": reqData['requestid'], "responsefor": "Read all", "responsesetto": reqData['requestsrc'], "response": {"message": "Some error in request"}}
            return respfail    
    else:
        respfail={"responseid": reqData['requestid'], "responsefor": "Read all", "responsesetto": reqData['requestsrc'], "response": {"message": "Some error in request"}}
        return respfail
    
 #1.5. Delete One Conditional
def dbplans_processdeleteonecond(reqData):
    if reqData['requestdata']['dbplansid']:
        data = reqData['requestdata']['dbplansid']
        sta = dbilayer.updateValuesIndb('dbplans',"status ='9'" ,"dbplansid = {}".format(data))
        print(sta)
        if(sta == "Success"):
            respsucc = {"responseid": reqData['requestid'], "responsefor":"dbPlans_processdeleteonecond","responseto":"UI","responsedata": {"message":"Deleted Successfully"}}
            return  respsucc
        elif(sta == 'Failed'):
            respfail = {"responseid": reqData['requestid'], "responsefor":"dbPlans_processdeleteonecond","responseto":"UI","responsedata": {"message":"Delete request Failed"}}
            return  respfail
    else:
        respfail = {"responseid": reqData['requestid'], "responsefor":"dbPlans_processdeleteonecond","responseto":"UI","responsedata": {"message":"Error in Request"}}
        return  respfail   
    
#1.6. Update One Conditional
def dbplans_processupdateonecond(reqData):
    if isinstance(reqData, dict):
        data=reqData['requestdata']
        dbplansid = data['dbplansid']
        dbplansname=data['dbplansname']
        dbtypeid=data['dbtypeid']
        dbbillingid=data['dbbillingid']
        status = data['status']
        updateStatement = "dbplansname= '{}',dbtypeid= {},dbbillingid= {},status = '{}'".format(dbplansname,dbtypeid,dbbillingid,status)
        condition = "dbplansid = {}".format(dbplansid)
        sta = dbilayer.updateValuesIndb('dbplans', updateStatement, condition)
        print(sta)
        if(sta == "Success"):
            respsucc = {"responseid": reqData['requestid'], "responsefor":"Update data","responsesetto": reqData['requestsrc'],"responsedata": {"message":"Success"}}
            return  respsucc
        elif(sta == 'Failed'):
            respfail = {"responseid": reqData['requestid'], "responsefor":"Update data","responsesetto": reqData['requestsrc'],"responsedata": {"message":"Failed"}}
            return  respfail
    else:
        respfail = {"responseid": reqData['requestid'], "responsefor":"Update data","responsesetto": reqData['requestsrc'],"responsedata": {"message":"Error in Request"}}
        return  respfail

#1.7. Update All
def dbplans_processupdateall(req):
     pass



## Functions for dbPO
# 1.1. Create
def dbpo_processcreate(reqData):
    if isinstance(reqData, dict):
        #data_to_insert, ids_of_stored = generate_unique_ids('pagename','pagelayoutpropid',reqData, 'pagelayoutnprops')
        #print("all stored ids in db", data_to_insert, ids_of_stored)
        data_to_insert = reqData["requestdata"]
        data=tuple(data_to_insert.values())
        sta=dbilayer.insertIntoDBWithoutCondition('dbpo',constants.column_dbpo_table, data)
        if(sta == "Success"):
            respsucc={"responseid": reqData['requestid'], "responsefor": "Create", "responsesetto": reqData['requestsrc'], "response": {"message": "Success"}}
            return respsucc
        else:
            respfail={"responseid": reqData['requestid'], "responsefor": "Create", "responsesetto": reqData['requestsrc'], "response": {"message": "Some Error in Request"}}
            return respfail
    else:
        respfail={"responseid": reqData['requestid'], "responsefor": "Create", "responsesetto": reqData['requestsrc'], "response": {"message": "Error Encountered"}}
        return respfail


# 1.2. Read One Conditional
def dbpo_processreadonecond(reqData):
    if isinstance(reqData, dict):
        condition_data=reqData['requestdata']
        condition = "dbpoid = {} AND status = '{}'".format(condition_data["dbpoid"], condition_data["status"])
        sta=dbilayer.readOneWithcondition('dbpo', '*', condition,tablesdict.dbpo_table)
        print(sta)
        #sta=common.list2dict(sta)
        if (len(sta) >= 1):
            respsucc={"responseid": reqData['requestid'], "responsefor": "Read one", "responsesetto": reqData['requestsrc'], "response": {"message": sta}}
            return respsucc
        else:
            respfail={"responseid": reqData['requestid'], "responsefor": "Read one", "responsesetto": reqData['requestsrc'], "response": {"message": "No data Received!"}}
            return respfail
    else:
        respfail={"responseid": reqData['requestid'], "responsefor": "Read one", "responsesetto": reqData['requestsrc'], "response": {"message": "Error Encountered"}}
        return respfail    


# 1.3. Read Multiple Conditional
def dbpo_processreadmanycond(reqData):
    if isinstance(reqData, dict):
        condition_data=reqData['requestdata']
        condition_data = "status = '{}'".format(condition_data["status"])
        sta=dbilayer.readOneWithcondition('dbpo', '*', condition_data,tablesdict.dbpo_table)
        if (len(sta) >= 1):
            #sta=common.list2dict(sta)
            respsucc={"responseid": reqData['requestid'], "responsefor": "Read all with condition", "responsesetto": reqData['requestsrc'], "response": {"message": sta}}
            return respsucc
        else:
            respfail={"responseid": reqData['requestid'], "responsefor": "Read all with condition", "responsesetto": reqData['requestsrc'], "response":{"message": "No data received!"}}
            return respfail
    else:
        respfail={"responseid": reqData['requestid'], "responsefor": "Read all with condition", "responsesetto": reqData['requestsrc'], "response": {"message": "Error Encountered"}}
        return respfail
    

# 1.4. Read All without condition
def dbpo_processreadmanywithoutcond(reqData):
    if isinstance(reqData, dict):
        if reqData['requestdata']['dbpoid'] == "all":
            sta=dbilayer.readallWithoutCondition('dbpo', '*',tablesdict.dbpo_table)
            #sta=common.list2dict(sta)
            if (len(sta) >= 1):
                respsucc={"responseid": reqData['requestid'], "responsefor": "Read all", "responsesetto": reqData['requestsrc'], "response": {"message": sta}}
                return respsucc
            else:
                respfail={"responseid": reqData['requestid'], "responsefor": "Read all", "responsesetto": reqData['requestsrc'], "response": {"message": "No data Received!"}}
                return respfail
        else:
            respfail={"responseid": reqData['requestid'], "responsefor": "Read all", "responsesetto": reqData['requestsrc'], "response": {"message": "Some error in request"}}
            return respfail    
    else:
        respfail={"responseid": reqData['requestid'], "responsefor": "Read all", "responsesetto": reqData['requestsrc'], "response": {"message": "Some error in request"}}
        return respfail
    
 #1.5. Delete One Conditional
def dbpo_processdeleteonecond(reqData):
    if reqData['requestdata']['dbpoid']:
        data = reqData['requestdata']['dbpoid']
        sta = dbilayer.updateValuesIndb('dbpo',"status ='9'" ,"dbpoid = {}".format(data))
        print(sta)
        if(sta == "Success"):
            respsucc = {"responseid": reqData['requestid'], "responsefor":"dbPO_processdeleteonecond","responseto":"UI","responsedata": {"message":"Deleted Successfully"}}
            return  respsucc
        elif(sta == 'Failed'):
            respfail = {"responseid": reqData['requestid'], "responsefor":"dbPO_processdeleteonecond","responseto":"UI","responsedata": {"message":"Delete request Failed"}}
            return  respfail
    else:
        respfail = {"responseid": reqData['requestid'], "responsefor":"dbPO_processdeleteonecond","responseto":"UI","responsedata": {"message":"Error in Request"}}
        return  respfail   
    
#1.6. Update One Conditional
def dbpo_processupdateonecond(reqData):
    if isinstance(reqData, dict):
        data=reqData['requestdata']
        dbponumber = data['dbponumber']
        dbpoid=data['dbpoid']
        dbinvoiceid=data['dbinvoiceid']
        dbbillingid=data['dbbillingid']
        dbcustomerid=data['dbcustomerid']
        dborganizationid=data['dborganizationid']
        status = data['status']
        updateStatement = "dbponumber= '{}',dbinvoiceid= {},dbbillingid= {},dbcustomerid= {},dborganizationid= {},status = '{}'".format(dbponumber,dbinvoiceid,dbbillingid,dbcustomerid,dborganizationid,status)
        condition = "dbpoid = {}".format(dbpoid)
        sta = dbilayer.updateValuesIndb('dbpo', updateStatement, condition)
        print(sta)
        if(sta == "Success"):
            respsucc = {"responseid": reqData['requestid'], "responsefor":"Update data","responsesetto": reqData['requestsrc'],"responsedata": {"message":"Success"}}
            return  respsucc
        elif(sta == 'Failed'):
            respfail = {"responseid": reqData['requestid'], "responsefor":"Update data","responsesetto": reqData['requestsrc'],"responsedata": {"message":"Failed"}}
            return  respfail
    else:
        respfail = {"responseid": reqData['requestid'], "responsefor":"Update data","responsesetto": reqData['requestsrc'],"responsedata": {"message":"Error in Request"}}
        return  respfail

#1.7. Update All
def dbpo_processupdateall(req):
     pass



## Functions for dbPortNumber
# 1.1. Create
def dbportnumber_processcreate(reqData):
    if isinstance(reqData, dict):
        #data_to_insert, ids_of_stored = generate_unique_ids('pagename','pagelayoutpropid',reqData, 'pagelayoutnprops')
        #print("all stored ids in db", data_to_insert, ids_of_stored)
        data_to_insert = reqData["requestdata"]
        data=tuple(data_to_insert.values())
        sta=dbilayer.insertIntoDBWithoutCondition('dbportnumber',constants.column_dbportnumber_table, data)
        if(sta == "Success"):
            respsucc={"responseid": reqData['requestid'], "responsefor": "Create", "responsesetto": reqData['requestsrc'], "response": {"message": "Success"}}
            return respsucc
        else:
            respfail={"responseid": reqData['requestid'], "responsefor": "Create", "responsesetto": reqData['requestsrc'], "response": {"message": "Some Error in Request"}}
            return respfail
    else:
        respfail={"responseid": reqData['requestid'], "responsefor": "Create", "responsesetto": reqData['requestsrc'], "response": {"message": "Error Encountered"}}
        return respfail


# 1.2. Read One Conditional
def dbportnumber_processreadonecond(reqData):
    if isinstance(reqData, dict):
        condition_data=reqData['requestdata']
        condition = "dbportid = {} AND status = '{}'".format(condition_data["dbportid"], condition_data["status"])
        sta=dbilayer.readOneWithcondition('dbportnumber', '*', condition,tablesdict.dbportnumber_table)
        print(sta)
        #sta=common.list2dict(sta)
        if (len(sta) >= 1):
            respsucc={"responseid": reqData['requestid'], "responsefor": "Read one", "responsesetto": reqData['requestsrc'], "response": {"message": sta}}
            return respsucc
        else:
            respfail={"responseid": reqData['requestid'], "responsefor": "Read one", "responsesetto": reqData['requestsrc'], "response": {"message": "No data Received!"}}
            return respfail
    else:
        respfail={"responseid": reqData['requestid'], "responsefor": "Read one", "responsesetto": reqData['requestsrc'], "response": {"message": "Error Encountered"}}
        return respfail    


# 1.3. Read Multiple Conditional
def dbportnumber_processreadmanycond(reqData):
    if isinstance(reqData, dict):
        condition_data=reqData['requestdata']
        condition_data = "status = '{}'".format(condition_data["status"])
        sta=dbilayer.readOneWithcondition('dbportnumber', '*', condition_data,tablesdict.dbportnumber_table)
        if (len(sta) >= 1):
            #sta=common.list2dict(sta)
            respsucc={"responseid": reqData['requestid'], "responsefor": "Read all with condition", "responsesetto": reqData['requestsrc'], "response": {"message": sta}}
            return respsucc
        else:
            respfail={"responseid": reqData['requestid'], "responsefor": "Read all with condition", "responsesetto": reqData['requestsrc'], "response":{"message": "No data received!"}}
            return respfail
    else:
        respfail={"responseid": reqData['requestid'], "responsefor": "Read all with condition", "responsesetto": reqData['requestsrc'], "response": {"message": "Error Encountered"}}
        return respfail
    

# 1.4. Read All without condition
def dbportnumber_processreadmanywithoutcond(reqData):
    if isinstance(reqData, dict):
        if reqData['requestdata']['dbportid'] == "all":
            sta=dbilayer.readallWithoutCondition('dbportnumber', '*',tablesdict.dbportnumber_table)
            #sta=common.list2dict(sta)
            if (len(sta) >= 1):
                respsucc={"responseid": reqData['requestid'], "responsefor": "Read all", "responsesetto": reqData['requestsrc'], "response": {"message": sta}}
                return respsucc
            else:
                respfail={"responseid": reqData['requestid'], "responsefor": "Read all", "responsesetto": reqData['requestsrc'], "response": {"message": "No data Received!"}}
                return respfail
        else:
            respfail={"responseid": reqData['requestid'], "responsefor": "Read all", "responsesetto": reqData['requestsrc'], "response": {"message": "Some error in request"}}
            return respfail    
    else:
        respfail={"responseid": reqData['requestid'], "responsefor": "Read all", "responsesetto": reqData['requestsrc'], "response": {"message": "Some error in request"}}
        return respfail
    
 #1.5. Delete One Conditional
def dbportnumber_processdeleteonecond(reqData):
    if reqData['requestdata']['dbportid']:
        data = reqData['requestdata']['dbportid']
        sta = dbilayer.updateValuesIndb('dbPortNumber',"status ='9'" ,"dbportid = {}".format(data))
        print(sta)
        if(sta == "Success"):
            respsucc = {"responseid": reqData['requestid'], "responsefor":"dbPortNumber_processdeleteonecond","responseto":"UI","responsedata": {"message":"Deleted Successfully"}}
            return  respsucc
        elif(sta == 'Failed'):
            respfail = {"responseid": reqData['requestid'], "responsefor":"dbPortNumber_processdeleteonecond","responseto":"UI","responsedata": {"message":"Delete request Failed"}}
            return  respfail
    else:
        respfail = {"responseid": reqData['requestid'], "responsefor":"dbPortNumber_processdeleteonecond","responseto":"UI","responsedata": {"message":"Error in Request"}}
        return  respfail   
    
#1.6. Update One Conditional
def dbportnumber_processupdateonecond(reqData):
    if isinstance(reqData, dict):
        data=reqData['requestdata']
        dbportnumbername = data['dbportnumbername']
        dbportid=data['dbportid']
        dbportnumbercategory=data['dbportnumbercategory']
        dbportnumberdesc=data['dbportnumberdesc']
        dbcountryid=data['dbcountryid']
        dbpincodeid=data['dbpincodeid']
        dbusernameid=data['dbusernameid']
        dbpasswordid=data['dbpasswordid']
        status = data['status']
        updateStatement = "dbportnumbername= '{}',dbportnumbercategory= '{}',dbportnumberdesc= '{}',dbcountryid= {},dbpincodeid= {},dbusernameid= {},dbpasswordid= {},status = '{}'".format(dbportnumbername,dbportnumbercategory,dbportnumberdesc,dbcountryid,dbpincodeid,dbusernameid,dbpasswordid,status)
        condition = "dbportid = {}".format(dbportid)
        sta = dbilayer.updateValuesIndb('dbportnumber', updateStatement, condition)
        print(sta)
        if(sta == "Success"):
            respsucc = {"responseid": reqData['requestid'], "responsefor":"Update data","responsesetto": reqData['requestsrc'],"responsedata": {"message":"Success"}}
            return  respsucc
        elif(sta == 'Failed'):
            respfail = {"responseid": reqData['requestid'], "responsefor":"Update data","responsesetto": reqData['requestsrc'],"responsedata": {"message":"Failed"}}
            return  respfail
    else:
        respfail = {"responseid": reqData['requestid'], "responsefor":"Update data","responsesetto": reqData['requestsrc'],"responsedata": {"message":"Error in Request"}}
        return  respfail

#1.7. Update All
def dbportnumber_processupdateall(req):
     pass


## Functions for dbProd
# 1.1. Create
def dbprod_processcreate(reqData):
    if isinstance(reqData, dict):
        #data_to_insert, ids_of_stored = generate_unique_ids('pagename','pagelayoutpropid',reqData, 'pagelayoutnprops')
        #print("all stored ids in db", data_to_insert, ids_of_stored)
        data_to_insert = reqData["requestdata"]
        data=tuple(data_to_insert.values())
        sta=dbilayer.insertIntoDBWithoutCondition('dbprod',constants.column_dbprod_table, data)
        if(sta == "Success"):
            respsucc={"responseid": reqData['requestid'], "responsefor": "Create", "responsesetto": reqData['requestsrc'], "response": {"message": "Success"}}
            return respsucc
        else:
            respfail={"responseid": reqData['requestid'], "responsefor": "Create", "responsesetto": reqData['requestsrc'], "response": {"message": "Some Error in Request"}}
            return respfail
    else:
        respfail={"responseid": reqData['requestid'], "responsefor": "Create", "responsesetto": reqData['requestsrc'], "response": {"message": "Error Encountered"}}
        return respfail


# 1.2. Read One Conditional
def dbprod_processreadonecond(reqData):
    if isinstance(reqData, dict):
        condition_data=reqData['requestdata']
        condition = "dbprodid = {} AND status = '{}'".format(condition_data["dbprodid"], condition_data["status"])
        sta=dbilayer.readOneWithcondition('dbprod', '*', condition,tablesdict.dbprod_table)
        print(sta)
        #sta=common.list2dict(sta)
        if (len(sta) >= 1):
            respsucc={"responseid": reqData['requestid'], "responsefor": "Read one", "responsesetto": reqData['requestsrc'], "response": {"message": sta}}
            return respsucc
        else:
            respfail={"responseid": reqData['requestid'], "responsefor": "Read one", "responsesetto": reqData['requestsrc'], "response": {"message": "No data Received!"}}
            return respfail
    else:
        respfail={"responseid": reqData['requestid'], "responsefor": "Read one", "responsesetto": reqData['requestsrc'], "response": {"message": "Error Encountered"}}
        return respfail    


# 1.3. Read Multiple Conditional
def dbprod_processreadmanycond(reqData):
    if isinstance(reqData, dict):
        condition_data=reqData['requestdata']
        condition_data = "status = '{}'".format(condition_data["status"])
        sta=dbilayer.readOneWithcondition('dbprod', '*', condition_data,tablesdict.dbprod_table)
        if (len(sta) >= 1):
            #sta=common.list2dict(sta)
            respsucc={"responseid": reqData['requestid'], "responsefor": "Read all with condition", "responsesetto": reqData['requestsrc'], "response": {"message": sta}}
            return respsucc
        else:
            respfail={"responseid": reqData['requestid'], "responsefor": "Read all with condition", "responsesetto": reqData['requestsrc'], "response":{"message": "No data received!"}}
            return respfail
    else:
        respfail={"responseid": reqData['requestid'], "responsefor": "Read all with condition", "responsesetto": reqData['requestsrc'], "response": {"message": "Error Encountered"}}
        return respfail
    

# 1.4. Read All without condition
def dbprod_processreadmanywithoutcond(reqData):
    if isinstance(reqData, dict):
        if reqData['requestdata']['dbprodid'] == "all":
            sta=dbilayer.readallWithoutCondition('dbprod', '*',tablesdict.dbprod_table)
            #sta=common.list2dict(sta)
            if (len(sta) >= 1):
                respsucc={"responseid": reqData['requestid'], "responsefor": "Read all", "responsesetto": reqData['requestsrc'], "response": {"message": sta}}
                return respsucc
            else:
                respfail={"responseid": reqData['requestid'], "responsefor": "Read all", "responsesetto": reqData['requestsrc'], "response": {"message": "No data Received!"}}
                return respfail
        else:
            respfail={"responseid": reqData['requestid'], "responsefor": "Read all", "responsesetto": reqData['requestsrc'], "response": {"message": "Some error in request"}}
            return respfail    
    else:
        respfail={"responseid": reqData['requestid'], "responsefor": "Read all", "responsesetto": reqData['requestsrc'], "response": {"message": "Some error in request"}}
        return respfail
    
 #1.5. Delete One Conditional
def dbprod_processdeleteonecond(reqData):
    if reqData['requestdata']['dbprodid']:
        data = reqData['requestdata']['dbprodid']
        sta = dbilayer.updateValuesIndb('dbprod',"status ='9'" ,"dbprodid = {}".format(data))
        print(sta)
        if(sta == "Success"):
            respsucc = {"responseid": reqData['requestid'], "responsefor":"dbProd_processdeleteonecond","responseto":"UI","responsedata": {"message":"Deleted Successfully"}}
            return  respsucc
        elif(sta == 'Failed'):
            respfail = {"responseid": reqData['requestid'], "responsefor":"dbProd_processdeleteonecond","responseto":"UI","responsedata": {"message":"Delete request Failed"}}
            return  respfail
    else:
        respfail = {"responseid": reqData['requestid'], "responsefor":"dbProd_processdeleteonecond","responseto":"UI","responsedata": {"message":"Error in Request"}}
        return  respfail   
    
#1.6. Update One Conditional
def dbprod_processupdateonecond(reqData):
    if isinstance(reqData, dict):
        data=reqData['requestdata']
        dbprodname = data['dbprodname']
        dbprodid=data['dbprodid']
        status = data['status']
        updateStatement = "dbprodname= '{}',status = '{}'".format(dbprodname,status)
        condition = "dbprodid = {}".format(dbprodid)
        sta = dbilayer.updateValuesIndb('dbprod', updateStatement, condition)
        print(sta)
        if(sta == "Success"):
            respsucc = {"responseid": reqData['requestid'], "responsefor":"Update data","responsesetto": reqData['requestsrc'],"responsedata": {"message":"Success"}}
            return  respsucc
        elif(sta == 'Failed'):
            respfail = {"responseid": reqData['requestid'], "responsefor":"Update data","responsesetto": reqData['requestsrc'],"responsedata": {"message":"Failed"}}
            return  respfail
    else:
        respfail = {"responseid": reqData['requestid'], "responsefor":"Update data","responsesetto": reqData['requestsrc'],"responsedata": {"message":"Error in Request"}}
        return  respfail

#1.7. Update All
def dbprod_processupdateall(req):
     pass



## Functions for dbRole
# 1.1. Create
def dbrole_processcreate(reqData):
    if isinstance(reqData, dict):
        #data_to_insert, ids_of_stored = generate_unique_ids('pagename','pagelayoutpropid',reqData, 'pagelayoutnprops')
        #print("all stored ids in db", data_to_insert, ids_of_stored)
        data_to_insert = reqData["requestdata"]
        data=tuple(data_to_insert.values())
        sta=dbilayer.insertIntoDBWithoutCondition('dbrole',constants.column_dbrole_table , data)
        if(sta == "Success"):
            respsucc={"responseid": reqData['requestid'], "responsefor": "Create", "responsesetto": reqData['requestsrc'], "response": {"message": "Success"}}
            return respsucc
        else:
            respfail={"responseid": reqData['requestid'], "responsefor": "Create", "responsesetto": reqData['requestsrc'], "response": {"message": "Some Error in Request"}}
            return respfail
    else:
        respfail={"responseid": reqData['requestid'], "responsefor": "Create", "responsesetto": reqData['requestsrc'], "response": {"message": "Error Encountered"}}
        return respfail


# 1.2. Read One Conditional
def dbrole_processreadonecond(reqData):
    if isinstance(reqData, dict):
        condition_data=reqData['requestdata']
        condition = "dbroleid = {} AND status = '{}'".format(condition_data["dbroleid"], condition_data["status"])
        sta=dbilayer.readOneWithcondition('dbrole', '*', condition,tablesdict.dbrole_table)
        print(sta)
        #sta=common.list2dict(sta)
        if (len(sta) >= 1):
            respsucc={"responseid": reqData['requestid'], "responsefor": "Read one", "responsesetto": reqData['requestsrc'], "response": {"message": sta}}
            return respsucc
        else:
            respfail={"responseid": reqData['requestid'], "responsefor": "Read one", "responsesetto": reqData['requestsrc'], "response": {"message": "No data Received!"}}
            return respfail
    else:
        respfail={"responseid": reqData['requestid'], "responsefor": "Read one", "responsesetto": reqData['requestsrc'], "response": {"message": "Error Encountered"}}
        return respfail    


# 1.3. Read Multiple Conditional
def dbrole_processreadmanycond(reqData):
    if isinstance(reqData, dict):
        condition_data=reqData['requestdata']
        condition_data = "status = '{}'".format(condition_data["status"])
        sta=dbilayer.readOneWithcondition('dbrole', '*', condition_data,tablesdict.dbrole_table)
        if (len(sta) >= 1):
            #sta=common.list2dict(sta)
            respsucc={"responseid": reqData['requestid'], "responsefor": "Read all with condition", "responsesetto": reqData['requestsrc'], "response": {"message": sta}}
            return respsucc
        else:
            respfail={"responseid": reqData['requestid'], "responsefor": "Read all with condition", "responsesetto": reqData['requestsrc'], "response":{"message": "No data received!"}}
            return respfail
    else:
        respfail={"responseid": reqData['requestid'], "responsefor": "Read all with condition", "responsesetto": reqData['requestsrc'], "response": {"message": "Error Encountered"}}
        return respfail
    

# 1.4. Read All without condition
def dbrole_processreadmanywithoutcond(reqData):
    if isinstance(reqData, dict):
        if reqData['requestdata']['dbroleid'] == "all":
            sta=dbilayer.readallWithoutCondition('dbrole', '*',tablesdict.dbrole_table)
            #sta=common.list2dict(sta)
            if (len(sta) >= 1):
                respsucc={"responseid": reqData['requestid'], "responsefor": "Read all", "responsesetto": reqData['requestsrc'], "response": {"message": sta}}
                return respsucc
            else:
                respfail={"responseid": reqData['requestid'], "responsefor": "Read all", "responsesetto": reqData['requestsrc'], "response": {"message": "No data Received!"}}
                return respfail
        else:
            respfail={"responseid": reqData['requestid'], "responsefor": "Read all", "responsesetto": reqData['requestsrc'], "response": {"message": "Some error in request"}}
            return respfail    
    else:
        respfail={"responseid": reqData['requestid'], "responsefor": "Read all", "responsesetto": reqData['requestsrc'], "response": {"message": "Some error in request"}}
        return respfail
    
 #1.5. Delete One Conditional
def dbrole_processdeleteonecond(reqData):
    if reqData['requestdata']['dbroleid']:
        data = reqData['requestdata']['dbroleid']
        sta = dbilayer.updateValuesIndb('dbrole',"status ='9'" ,"dbroleid = {}".format(data))
        print(sta)
        if(sta == "Success"):
            respsucc = {"responseid": reqData['requestid'], "responsefor":"dbRole_processdeleteonecond","responseto":"UI","responsedata": {"message":"Deleted Successfully"}}
            return  respsucc
        elif(sta == 'Failed'):
            respfail = {"responseid": reqData['requestid'], "responsefor":"dbRole_processdeleteonecond","responseto":"UI","responsedata": {"message":"Delete request Failed"}}
            return  respfail
    else:
        respfail = {"responseid": reqData['requestid'], "responsefor":"dbRole_processdeleteonecond","responseto":"UI","responsedata": {"message":"Error in Request"}}
        return  respfail   
    
#1.6. Update One Conditional
def dbrole_processupdateonecond(reqData):
    if isinstance(reqData, dict):
        data=reqData['requestdata']
        dbrolename = data['dbrolename']
        dbroleid=data['dbroleid']
        dbuserid=data['dbuserid']
        dbroledesc=data['dbroledesc']
        dbpermissionid=data['dbpermissionid']
        status = data['status']
        updateStatement = "dbrolename= '{}',dbuserid= {},dbroledesc= '{}',dbpermissionid= {},status = '{}'".format(dbrolename,dbuserid,dbroledesc,dbpermissionid,status)
        condition = "dbroleid = {}".format(dbroleid)
        sta = dbilayer.updateValuesIndb('dbrole', updateStatement, condition)
        print(sta)
        if(sta == "Success"):
            respsucc = {"responseid": reqData['requestid'], "responsefor":"Update data","responsesetto": reqData['requestsrc'],"responsedata": {"message":"Success"}}
            return  respsucc
        elif(sta == 'Failed'):
            respfail = {"responseid": reqData['requestid'], "responsefor":"Update data","responsesetto": reqData['requestsrc'],"responsedata": {"message":"Failed"}}
            return  respfail
    else:
        respfail = {"responseid": reqData['requestid'], "responsefor":"Update data","responsesetto": reqData['requestsrc'],"responsedata": {"message":"Error in Request"}}
        return  respfail

#1.7. Update All
def dbrole_processupdateall(req):
     pass


## Functions for DBBILLING
# 1.1. Read All without condition
def dbbilling_processreadall(reqData):
    if isinstance(reqData, dict):
        if reqData['requestdata']['dbbillingid'] == "all":
            sta=dbilayer.readallWithoutCondition('dbbilling', '*',tablesdict.dbbilling_table)
            #sta=common.list2dict(sta)
            if (len(sta) >= 1):
                respsucc={"responseid": reqData['requestid'], "responsefor": "Read all", "responsesetto": reqData['requestsrc'], "response": {"message": sta}}
                return respsucc
            else:
                respfail={"responseid": reqData['requestid'], "responsefor": "Read all", "responsesetto": reqData['requestsrc'], "response": {"message": "No data Received!"}}
                return respfail
        else:
            respfail={"responseid": reqData['requestid'], "responsefor": "Read all", "responsesetto": reqData['requestsrc'], "response": {"message": "Some error in request"}}
            return respfail    
    else:
        respfail={"responseid": reqData['requestid'], "responsefor": "Read all", "responsesetto": reqData['requestsrc'], "response": {"message": "Some error in request"}}
        return respfail
    
# 1.2. Read Multiple Conditional
def dbbilling_processreadmanycond(reqData):
    if isinstance(reqData, dict):
        condition_data=reqData['requestdata']
        condition_data = "status = '{}'".format(condition_data["status"])
        print(condition_data)
        print()
        print()
        print()
        print()
        print()
        print()
        sta=dbilayer.readOneWithcondition('dbbilling', '*', condition_data,tablesdict.dbbilling_table)
        print(sta)
        if (len(sta) >= 1):
            #sta=common.list2dict(sta)
            respsucc={"responseid": reqData['requestid'], "responsefor": "Read all with condition", "responsesetto": reqData['requestsrc'], "response": {"message": sta}}
            return respsucc
        else:
            respfail={"responseid": reqData['requestid'], "responsefor": "Read all with condition", "responsesetto": reqData['requestsrc'], "response":{"message": "No data received!"}}
            return respfail
    else:
        respfail={"responseid": reqData['requestid'], "responsefor": "Read all with condition", "responsesetto": reqData['requestsrc'], "response": {"message": "Error Encountered"}}
        return respfail
    
# 1.3. Read One Conditional
def dbbilling_processreadonecond(reqData):
    if isinstance(reqData, dict):
        condition_data=reqData['requestdata']
        condition = "dbbillingid = {} AND status = '{}'".format(condition_data["dbbillingid"], condition_data["status"])
        sta=dbilayer.readOneWithcondition('dbbilling','*', condition,tablesdict.dbbilling_table)
        print(sta)
        #sta=common.list2dict(sta)
        if (len(sta) >= 1):
            respsucc={"responseid": reqData['requestid'], "responsefor": "Read one", "responsesetto": reqData['requestsrc'], "response": {"message": sta}}
            return respsucc
        else:
            respfail={"responseid": reqData['requestid'], "responsefor": "Read one", "responsesetto": reqData['requestsrc'], "response": {"message": "No data Received!"}}
            return respfail
    else:
        respfail={"responseid": reqData['requestid'], "responsefor": "Read one", "responsesetto": reqData['requestsrc'], "response": {"message": "Error Encountered"}}
        return respfail    

# 1.4. Create
def dbbilling_processcreate(reqData):
    if isinstance(reqData, dict):
        #data_to_insert, ids_of_stored = generate_unique_ids('pagename','pagelayoutpropid',reqData, 'pagelayoutnprops')
        #print("all stored ids in db", data_to_insert, ids_of_stored)
        data_to_insert = reqData["requestdata"]
        print(data_to_insert)
        data=tuple(data_to_insert.values())
        sta=dbilayer.insertIntoDBWithoutCondition('dbBilling',constants.column_dbbilling_table, data)
        if(sta == "Success"):
            respsucc={"responseid": reqData['requestid'], "responsefor": "Create", "responsesetto": reqData['requestsrc'], "response": {"message": "Success"}}
            return respsucc
        else:
            respfail={"responseid": reqData['requestid'], "responsefor": "Create", "responsesetto": reqData['requestsrc'], "response": {"message": "Some Error in Request"}}
            return respfail
    else:
        respfail={"responseid": reqData['requestid'], "responsefor": "Create", "responsesetto": reqData['requestsrc'], "response": {"message": "Error Encountered"}}
        return respfail
    
 #1.5. Delete One Conditional
def dbbilling_processdeleteonecond(reqData):
    if reqData['requestdata']['dbbillingid']:
        data = reqData['requestdata']['dbbillingid']
        sta = dbilayer.updateValuesIndb('dbBilling',"status ='9'" ,"dbbillingid ={}".format(data))
        print(sta)
        if(sta == "Success"):
            respsucc = {"responseid": reqData['requestid'], "responsefor":"dbbilling_processdeleteonecond","responseto":"UI","responsedata": {"message":"Deleted Successfully"}}
            return  respsucc
        elif(sta == 'Failed'):
            respfail = {"responseid": reqData['requestid'], "responsefor":"dbbilling_processdeleteonecond","responseto":"UI","responsedata": {"message":"Delete request Failed"}}
            return  respfail
    else:
        respfail = {"responseid": reqData['requestid'], "responsefor":"dbbilling_processdeleteonecond","responseto":"UI","responsedata": {"message":"Error in Request"}}
        return  respfail   
    
#1.6. Update One Conditional
def dbbilling_processupdateonecond(reqData):
    if isinstance(reqData, dict):
        data=reqData['requestdata']
        dbbillingid = data['dbbillingid']
        dbbillingname=data["dbbillingname"]
        dbcustomerid=data["dbcustomerid"]
        amount=data["amount"]
        dbbillingdate=data["dbbillingdate"]
        dbbillinglastupdate=data["dbbillinglastupdate"]
        dbinvoiceid=data["dbinvoiceid"]
        status = data['status']
        updateStatement = "dbbillingname = '{}',dbcustomerid={},amount = '{}',dbbillingdate='{}',dbbillinglastupdate='{}',dbinvoiceid={},status = '{}'".format(dbbillingname,dbcustomerid,amount,dbbillingdate,dbbillinglastupdate,dbinvoiceid,status)
        condition = "dbbillingid = {}".format(dbbillingid)
        sta = dbilayer.updateValuesIndb('dbbilling', updateStatement, condition)
        print(sta)
        if(sta == "Success"):
            respsucc = {"responseid": reqData['requestid'], "responsefor":"Update data","responsesetto": reqData['requestsrc'],"responsedata": {"message":"Success"}}
            return  respsucc
        elif(sta == 'Failed'):
            respfail = {"responseid": reqData['requestid'], "responsefor":"Update data","responsesetto": reqData['requestsrc'],"responsedata": {"message":"Failed"}}
            return  respfail
    else:
        respfail = {"responseid": reqData['requestid'], "responsefor":"Update data","responsesetto": reqData['requestsrc'],"responsedata": {"message":"Error in Request"}}
        return  respfail

#1.7. Update All
def dbbilling_processupdateall(req):
     pass

## Functions for DBCHARGE
# 1.1. Read All without condition
def dbcharge_processreadall(reqData):
    if isinstance(reqData, dict):
        if reqData['requestdata']['dbchargeid'] == "all":
            sta=dbilayer.readallWithoutCondition('dbCharges', '*',tablesdict.dbcharges_table)
            #sta=common.list2dict(sta)
            if (len(sta) >= 1):
                respsucc={"responseid": reqData['requestid'], "responsefor": "Read all", "responsesetto": reqData['requestsrc'], "response": {"message": sta}}
                return respsucc
            else:
                respfail={"responseid": reqData['requestid'], "responsefor": "Read all", "responsesetto": reqData['requestsrc'], "response": {"message": "No data Received!"}}
                return respfail
        else:
            respfail={"responseid": reqData['requestid'], "responsefor": "Read all", "responsesetto": reqData['requestsrc'], "response": {"message": "Some error in request"}}
            return respfail    
    else:
        respfail={"responseid": reqData['requestid'], "responsefor": "Read all", "responsesetto": reqData['requestsrc'], "response": {"message": "Some error in request"}}
        return respfail
    
# 1.2. Read Multiple Conditional
def dbcharge_processreadmanycond(reqData):
    if isinstance(reqData, dict):
        condition_data=reqData['requestdata']
        condition_data = "status = '{}'".format(condition_data["status"])
        sta=dbilayer.readOneWithcondition('dbCharges', '*', condition_data,tablesdict.dbcharges_table)
        if (len(sta) >= 1):
            #sta=common.list2dict(sta)
            respsucc={"responseid": reqData['requestid'], "responsefor": "Read all with condition", "responsesetto": reqData['requestsrc'], "response": {"message": sta}}
            return respsucc
        else:
            respfail={"responseid": reqData['requestid'], "responsefor": "Read all with condition", "responsesetto": reqData['requestsrc'], "response":{"message": "No data received!"}}
            return respfail
    else:
        respfail={"responseid": reqData['requestid'], "responsefor": "Read all with condition", "responsesetto": reqData['requestsrc'], "response": {"message": "Error Encountered"}}
        return respfail
    
# 1.3. Read One Conditional
def dbcharge_processreadonecond(reqData):
    if isinstance(reqData, dict):
        condition_data=reqData['requestdata']
        condition = "dbchargeid = {} AND status = '{}'".format(condition_data["dbchargeid"], condition_data["status"])
        sta=dbilayer.readOneWithcondition('dbcharges','*', condition,tablesdict.dbcharges_table)
        print(sta)
        #sta=common.list2dict(sta)
        if (len(sta) >= 1):
            respsucc={"responseid": reqData['requestid'], "responsefor": "Read one", "responsesetto": reqData['requestsrc'], "response": {"message": sta}}
            return respsucc
        else:
            respfail={"responseid": reqData['requestid'], "responsefor": "Read one", "responsesetto": reqData['requestsrc'], "response": {"message": "No data Received!"}}
            return respfail
    else:
        respfail={"responseid": reqData['requestid'], "responsefor": "Read one", "responsesetto": reqData['requestsrc'], "response": {"message": "Error Encountered"}}
        return respfail    

# 1.4. Create
def dbcharge_processcreate(reqData):
    if isinstance(reqData, dict):
        #data_to_insert, ids_of_stored = generate_unique_ids('pagename','pagelayoutpropid',reqData, 'pagelayoutnprops')
        #print("all stored ids in db", data_to_insert, ids_of_stored)
        data_to_insert = reqData["requestdata"]
        print(data_to_insert)
        data=tuple(data_to_insert.values())
        sta=dbilayer.insertIntoDBWithoutCondition('dbcharges',constants.column_dbcharges_table, data)
        if(sta == "Success"):
            respsucc={"responseid": reqData['requestid'], "responsefor": "Create", "responsesetto": reqData['requestsrc'], "response": {"message": "Success"}}
            return respsucc
        else:
            respfail={"responseid": reqData['requestid'], "responsefor": "Create", "responsesetto": reqData['requestsrc'], "response": {"message": "Some Error in Request"}}
            return respfail
    else:
        respfail={"responseid": reqData['requestid'], "responsefor": "Create", "responsesetto": reqData['requestsrc'], "response": {"message": "Error Encountered"}}
        return respfail
    
 #1.5. Delete One Conditional
def dbcharge_processdeleteonecond(reqData):
    if reqData['requestdata']['dbchargeid']:
        data = reqData['requestdata']['dbchargeid']
        sta = dbilayer.updateValuesIndb('dbcharges',"status ='9'" ,"dbchargeid = {}".format(data))
        print(sta)
        if(sta == "Success"):
            respsucc = {"responseid": reqData['requestid'], "responsefor":"dbcharge_processdeleteonecond","responseto":"UI","responsedata": {"message":"Deleted Successfully"}}
            return  respsucc
        elif(sta == 'Failed'):
            respfail = {"responseid": reqData['requestid'], "responsefor":"dbcharge_processdeleteonecond","responseto":"UI","responsedata": {"message":"Delete request Failed"}}
            return  respfail
    else:
        respfail = {"responseid": reqData['requestid'], "responsefor":"dbcharge_processdeleteonecond","responseto":"UI","responsedata": {"message":"Error in Request"}}
        return  respfail   
    
#1.6. Update One Conditional
def dbcharge_processupdateonecond(reqData):
    if isinstance(reqData, dict):
        data=reqData['requestdata']
        dbchargename=data["dbchargename"]
        dbchargeid = data['dbchargeid']
        dbschemaid=data["dbschemaid"]
        status = data['status']
        updateStatement = "dbchargename = '{}',dbschemaid={},status = '{}'".format(dbchargename,dbschemaid,status)
        condition = "dbchargeid = {}".format(dbchargeid)
        sta = dbilayer.updateValuesIndb('dbCharges', updateStatement, condition)
        print(sta)
    
        if(sta == "Success"):
            respsucc = {"responseid": reqData['requestid'], "responsefor":"Update data","responsesetto": reqData['requestsrc'],"responsedata": {"message":"Success"}}
            return  respsucc
        elif(sta == 'Failed'):
            respfail = {"responseid": reqData['requestid'], "responsefor":"Update data","responsesetto": reqData['requestsrc'],"responsedata": {"message":"Failed"}}
            return  respfail
    else:
        respfail = {"responseid": reqData['requestid'], "responsefor":"Update data","responsesetto": reqData['requestsrc'],"responsedata": {"message":"Error in Request"}}
        return  respfail

#1.7. Update All
def dbcharge_processupdateall(req):
     pass

## Functions for DBCITY
# 1.1. Read All without condition
def dbcity_processreadall(reqData):
    if isinstance(reqData, dict):
        if reqData['requestdata']['dbcityid'] == "all":
            sta=dbilayer.readallWithoutCondition('dbCity', '*',tablesdict.dbcity_table)
            #sta=common.list2dict(sta)
            if (len(sta) >= 1):
                respsucc={"responseid": reqData['requestid'], "responsefor": "Read all", "responsesetto": reqData['requestsrc'], "response": {"message": sta}}
                return respsucc
            else:
                respfail={"responseid": reqData['requestid'], "responsefor": "Read all", "responsesetto": reqData['requestsrc'], "response": {"message": "No data Received!"}}
                return respfail
        else:
            respfail={"responseid": reqData['requestid'], "responsefor": "Read all", "responsesetto": reqData['requestsrc'], "response": {"message": "Some error in request"}}
            return respfail    
    else:
        respfail={"responseid": reqData['requestid'], "responsefor": "Read all", "responsesetto": reqData['requestsrc'], "response": {"message": "Some error in request"}}
        return respfail
    
# 1.2. Read Multiple Conditional
def dbcity_processreadmanycond(reqData):
    if isinstance(reqData, dict):
        condition_data=reqData['requestdata']
        condition_data = "status = '{}'".format(condition_data["status"])
        sta=dbilayer.readOneWithcondition('dbcity', '*', condition_data,tablesdict.dbcity_table)
        if (len(sta) >= 1):
            #sta=common.list2dict(sta)
            respsucc={"responseid": reqData['requestid'], "responsefor": "Read all with condition", "responsesetto": reqData['requestsrc'], "response": {"message": sta}}
            return respsucc
        else:
            respfail={"responseid": reqData['requestid'], "responsefor": "Read all with condition", "responsesetto": reqData['requestsrc'], "response":{"message": "No data received!"}}
            return respfail
    else:
        respfail={"responseid": reqData['requestid'], "responsefor": "Read all with condition", "responsesetto": reqData['requestsrc'], "response": {"message": "Error Encountered"}}
        return respfail
    
# 1.3. Read One Conditional
def dbcity_processreadonecond(reqData):
    if isinstance(reqData, dict):
        condition_data=reqData['requestdata']
        condition = "dbcityid = {} AND status = '{}'".format(condition_data["dbcityid"], condition_data["status"])
        sta=dbilayer.readOneWithcondition('dbcity','*', condition,tablesdict.dbcity_table)
        print(sta)
        #sta=common.list2dict(sta)
        if (len(sta) >= 1):
            respsucc={"responseid": reqData['requestid'], "responsefor": "Read one", "responsesetto": reqData['requestsrc'], "response": {"message": sta}}
            return respsucc
        else:
            respfail={"responseid": reqData['requestid'], "responsefor": "Read one", "responsesetto": reqData['requestsrc'], "response": {"message": "No data Received!"}}
            return respfail
    else:
        respfail={"responseid": reqData['requestid'], "responsefor": "Read one", "responsesetto": reqData['requestsrc'], "response": {"message": "Error Encountered"}}
        return respfail    

# 1.4. Create
def dbcity_processcreate(reqData):
    if isinstance(reqData, dict):
        #data_to_insert, ids_of_stored = generate_unique_ids('pagename','pagelayoutpropid',reqData, 'pagelayoutnprops')
        #print("all stored ids in db", data_to_insert, ids_of_stored)
        data_to_insert = reqData["requestdata"]
        print(data_to_insert)
        data=tuple(data_to_insert.values())
        sta=dbilayer.insertIntoDBWithoutCondition('dbCity',constants.column_dbcity_table, data)
        if(sta == "Success"):
            respsucc={"responseid": reqData['requestid'], "responsefor": "Create", "responsesetto": reqData['requestsrc'], "response": {"message": "Success"}}
            return respsucc
        else:
            respfail={"responseid": reqData['requestid'], "responsefor": "Create", "responsesetto": reqData['requestsrc'], "response": {"message": "Some Error in Request"}}
            return respfail
    else:
        respfail={"responseid": reqData['requestid'], "responsefor": "Create", "responsesetto": reqData['requestsrc'], "response": {"message": "Error Encountered"}}
        return respfail
    
 #1.5. Delete One Conditional
def dbcity_processdeleteonecond(reqData):
    if reqData['requestdata']['dbcityid']:
        data = reqData['requestdata']['dbcityid']
        sta = dbilayer.updateValuesIndb('dbCity',"status ='9'" ,"dbcityid = {}".format(data))
        print(sta)
        if(sta == "Success"):
            respsucc = {"responseid": reqData['requestid'], "responsefor":"dbcity_processdeleteonecond","responseto":"UI","responsedata": {"message":"Deleted Successfully"}}
            return  respsucc
        elif(sta == 'Failed'):
            respfail = {"responseid": reqData['requestid'], "responsefor":"dbcity_processdeleteonecond","responseto":"UI","responsedata": {"message":"Delete request Failed"}}
            return  respfail
    else:
        respfail = {"responseid": reqData['requestid'], "responsefor":"dbcity_processdeleteonecond","responseto":"UI","responsedata": {"message":"Error in Request"}}
        return  respfail   
    
#1.6. Update One Conditional
def dbcity_processupdateonecond(reqData):
    if isinstance(reqData, dict):
        data=reqData['requestdata']
        dbcityname=data["dbcityname"]
        dbcityid = data['dbcityid']
        dbstateid=data["dbstateid"]
        status = data['status']
        updateStatement = "dbcityname = '{}', dbstateid={},status = '{}'".format(dbcityname,dbstateid,status)
        condition = "dbcityid = {}".format(dbcityid)
        sta = dbilayer.updateValuesIndb('dbcity', updateStatement, condition)
        print(sta)
        if(sta == "Success"):
            respsucc = {"responseid": reqData['requestid'], "responsefor":"Update data","responsesetto": reqData['requestsrc'],"responsedata": {"message":"Success"}}
            return  respsucc
        elif(sta == 'Failed'):
            respfail = {"responseid": reqData['requestid'], "responsefor":"Update data","responsesetto": reqData['requestsrc'],"responsedata": {"message":"Failed"}}
            return  respfail
    else:
        respfail = {"responseid": reqData['requestid'], "responsefor":"Update data","responsesetto": reqData['requestsrc'],"responsedata": {"message":"Error in Request"}}
        return  respfail

#1.7. Update All
def dbcity_processupdateall(req):
     pass

## Functions for DBCOLLECTION
# 1.1. Read All without condition
def dbcollection_processreadall(reqData):
    if isinstance(reqData, dict):
        if reqData['requestdata']['dbcollectionid'] == "all":
            sta=dbilayer.readallWithoutCondition('dbCollection', '*',tablesdict.dbcollection_table)
            #sta=common.list2dict(sta)
            if (len(sta) >= 1):
                respsucc={"responseid": reqData['requestid'], "responsefor": "Read all", "responsesetto": reqData['requestsrc'], "response": {"message": sta}}
                return respsucc
            else:
                respfail={"responseid": reqData['requestid'], "responsefor": "Read all", "responsesetto": reqData['requestsrc'], "response": {"message": "No data Received!"}}
                return respfail
        else:
            respfail={"responseid": reqData['requestid'], "responsefor": "Read all", "responsesetto": reqData['requestsrc'], "response": {"message": "Some error in request"}}
            return respfail    
    else:
        respfail={"responseid": reqData['requestid'], "responsefor": "Read all", "responsesetto": reqData['requestsrc'], "response": {"message": "Some error in request"}}
        return respfail
    
# 1.2. Read Multiple Conditional
def dbcollection_processreadmanycond(reqData):
    if isinstance(reqData, dict):
        condition_data=reqData['requestdata']
        condition_data = "status = '{}'".format(condition_data["status"])
        sta=dbilayer.readOneWithcondition('dbCollection', '*', condition_data,tablesdict.dbcollection_table)
        if (len(sta) >= 1):
            #sta=common.list2dict(sta)
            respsucc={"responseid": reqData['requestid'], "responsefor": "Read all with condition", "responsesetto": reqData['requestsrc'], "response": {"message": sta}}
            return respsucc
        else:
            respfail={"responseid": reqData['requestid'], "responsefor": "Read all with condition", "responsesetto": reqData['requestsrc'], "response":{"message": "No data received!"}}
            return respfail
    else:
        respfail={"responseid": reqData['requestid'], "responsefor": "Read all with condition", "responsesetto": reqData['requestsrc'], "response": {"message": "Error Encountered"}}
        return respfail
    
# 1.3. Read One Conditional
def dbcollection_processreadonecond(reqData):
    if isinstance(reqData, dict):
        condition_data=reqData['requestdata']
        condition = "dbcollectionid = {} AND status = '{}'".format(condition_data["dbcollectionid"], condition_data["status"])
        sta=dbilayer.readOneWithcondition('dbCollection','*', condition,tablesdict.dbcollection_table)
        print(sta)
        #sta=common.list2dict(sta)
        if (len(sta) >= 1):
            respsucc={"responseid": reqData['requestid'], "responsefor": "Read one", "responsesetto": reqData['requestsrc'], "response": {"message": sta}}
            return respsucc
        else:
            respfail={"responseid": reqData['requestid'], "responsefor": "Read one", "responsesetto": reqData['requestsrc'], "response": {"message": "No data Received!"}}
            return respfail
    else:
        respfail={"responseid": reqData['requestid'], "responsefor": "Read one", "responsesetto": reqData['requestsrc'], "response": {"message": "Error Encountered"}}
        return respfail    

# 1.4. Create
def dbcollection_processcreate(reqData):
    if isinstance(reqData, dict):
        #data_to_insert, ids_of_stored = generate_unique_ids('pagename','pagelayoutpropid',reqData, 'pagelayoutnprops')
        #print("all stored ids in db", data_to_insert, ids_of_stored)
        data_to_insert = reqData["requestdata"]
        print(data_to_insert)
        data=tuple(data_to_insert.values())
        sta=dbilayer.insertIntoDBWithoutCondition('dbCollection',constants.column_dbcollection_table, data)
        if(sta == "Success"):
            respsucc={"responseid": reqData['requestid'], "responsefor": "Create", "responsesetto": reqData['requestsrc'], "response": {"message": "Success"}}
            return respsucc
        else:
            respfail={"responseid": reqData['requestid'], "responsefor": "Create", "responsesetto": reqData['requestsrc'], "response": {"message": "Some Error in Request"}}
            return respfail
    else:
        respfail={"responseid": reqData['requestid'], "responsefor": "Create", "responsesetto": reqData['requestsrc'], "response": {"message": "Error Encountered"}}
        return respfail
    
 #1.5. Delete One Conditional
def dbcollection_processdeleteonecond(reqData):
    if reqData['requestdata']['dbcollectionid']:
        data = reqData['requestdata']['dbcollectionid']
        sta = dbilayer.updateValuesIndb('dbcollection',"status ='9'" ,"dbcollectionid = {}".format(data))
        print(sta)
        if(sta == "Success"):
            respsucc = {"responseid": reqData['requestid'], "responsefor":"dbcollection_processdeleteonecond","responseto":"UI","responsedata": {"message":"Deleted Successfully"}}
            return  respsucc
        elif(sta == 'Failed'):
            respfail = {"responseid": reqData['requestid'], "responsefor":"dbcollection_processdeleteonecond","responseto":"UI","responsedata": {"message":"Delete request Failed"}}
            return  respfail
    else:
        respfail = {"responseid": reqData['requestid'], "responsefor":"dbcollection_processdeleteonecond","responseto":"UI","responsedata": {"message":"Error in Request"}}
        return  respfail   
    
#1.6. Update One Conditional
def dbcollection_processupdateonecond(reqData):
    if isinstance(reqData, dict):
        data=reqData['requestdata']
        dbcollectionname=data["dbcollectionname"]
        dbcollectionid = data['dbcollectionid']
        status = data['status']
        updateStatement = "dbcollectionname = '{}',status = '{}'".format(dbcollectionname,status)
        condition = "dbcollectionid = {}".format(dbcollectionid)
        sta = dbilayer.updateValuesIndb('dbcollection', updateStatement, condition)
        print(sta)
        if(sta == "Success"):
            respsucc = {"responseid": reqData['requestid'], "responsefor":"Update data","responsesetto": reqData['requestsrc'],"responsedata": {"message":"Success"}}
            return  respsucc
        elif(sta == 'Failed'):
            respfail = {"responseid": reqData['requestid'], "responsefor":"Update data","responsesetto": reqData['requestsrc'],"responsedata": {"message":"Failed"}}
            return  respfail
    else:
        respfail = {"responseid": reqData['requestid'], "responsefor":"Update data","responsesetto": reqData['requestsrc'],"responsedata": {"message":"Error in Request"}}
        return  respfail

#1.7. Update All
def dbcollection_processupdateall(req):
     pass


## Functions for DBCONNECTIONSTRING
# 1.1. Read All without condition
def dbconnectionstring_processreadall(reqData):
    if isinstance(reqData, dict):
        if reqData['requestdata']['dbconnectionstringid'] == "all":
            sta=dbilayer.readallWithoutCondition('dbconnectionstring', '*',tablesdict.dbconnectionstring_table)
            #sta=common.list2dict(sta)
            if (len(sta) >= 1):
                respsucc={"responseid": reqData['requestid'], "responsefor": "Read all", "responsesetto": reqData['requestsrc'], "response": {"message": sta}}
                return respsucc
            else:
                respfail={"responseid": reqData['requestid'], "responsefor": "Read all", "responsesetto": reqData['requestsrc'], "response": {"message": "No data Received!"}}
                return respfail
        else:
            respfail={"responseid": reqData['requestid'], "responsefor": "Read all", "responsesetto": reqData['requestsrc'], "response": {"message": "Some error in request"}}
            return respfail    
    else:
        respfail={"responseid": reqData['requestid'], "responsefor": "Read all", "responsesetto": reqData['requestsrc'], "response": {"message": "Some error in request"}}
        return respfail
    
# 1.2. Read Multiple Conditional
def dbconnectionstring_processreadmanycond(reqData):
    if isinstance(reqData, dict):
        condition_data=reqData['requestdata']
        condition_data = "status = '{}'".format(condition_data["status"])
        sta=dbilayer.readOneWithcondition('dbconnectionstring', '*', condition_data,tablesdict.dbconnectionstring_table)
        if (len(sta) >= 1):
            #sta=common.list2dict(sta)
            respsucc={"responseid": reqData['requestid'], "responsefor": "Read all with condition", "responsesetto": reqData['requestsrc'], "response": {"message": sta}}
            return respsucc
        else:
            respfail={"responseid": reqData['requestid'], "responsefor": "Read all with condition", "responsesetto": reqData['requestsrc'], "response":{"message": "No data received!"}}
            return respfail
    else:
        respfail={"responseid": reqData['requestid'], "responsefor": "Read all with condition", "responsesetto": reqData['requestsrc'], "response": {"message": "Error Encountered"}}
        return respfail
    
# 1.3. Read One Conditional
def dbconnectionstring_processreadonecond(reqData):
    if isinstance(reqData, dict):
        condition_data=reqData['requestdata']
        condition = "dbconnectionstringid = {} AND status = '{}'".format(condition_data["dbconnectionstringid"], condition_data["status"])
        sta=dbilayer.readOneWithcondition('dbconnectionstring','*', condition,tablesdict.dbconnectionstring_table)
        print(sta)
        #sta=common.list2dict(sta)
        if (len(sta) >= 1):
            respsucc={"responseid": reqData['requestid'], "responsefor": "Read one", "responsesetto": reqData['requestsrc'], "response": {"message": sta}}
            return respsucc
        else:
            respfail={"responseid": reqData['requestid'], "responsefor": "Read one", "responsesetto": reqData['requestsrc'], "response": {"message": "No data Received!"}}
            return respfail
    else:
        respfail={"responseid": reqData['requestid'], "responsefor": "Read one", "responsesetto": reqData['requestsrc'], "response": {"message": "Error Encountered"}}
        return respfail    

# 1.4. Create
def dbconnectionstring_processcreate(reqData):
    if isinstance(reqData, dict):
        #data_to_insert, ids_of_stored = generate_unique_ids('pagename','pagelayoutpropid',reqData, 'pagelayoutnprops')
        #print("all stored ids in db", data_to_insert, ids_of_stored)
        data_to_insert = reqData["requestdata"]
        print(data_to_insert)
        data=tuple(data_to_insert.values())
        sta=dbilayer.insertIntoDBWithoutCondition('dbConnectionString',constants.column_dbconnectionstring_table, data)
        if(sta == "Success"):
            respsucc={"responseid": reqData['requestid'], "responsefor": "Create", "responsesetto": reqData['requestsrc'], "response": {"message": "Success"}}
            return respsucc
        else:
            respfail={"responseid": reqData['requestid'], "responsefor": "Create", "responsesetto": reqData['requestsrc'], "response": {"message": "Some Error in Request"}}
            return respfail
    else:
        respfail={"responseid": reqData['requestid'], "responsefor": "Create", "responsesetto": reqData['requestsrc'], "response": {"message": "Error Encountered"}}
        return respfail
    
 #1.5. Delete One Conditional
def dbconnectionstring_processdeleteonecond(reqData):
    if reqData['requestdata']['dbconnectionstringid']:
        data = reqData['requestdata']['dbconnectionstringid']
        sta = dbilayer.updateValuesIndb('dbConnectionString',"status ='9'" ,"dbconnectionstringid = {}".format(data))
        print(sta)
        if(sta == "Success"):
            respsucc = {"responseid": reqData['requestid'], "responsefor":"dbconnectionstring_processdeleteonecond","responseto":"UI","responsedata": {"message":"Deleted Successfully"}}
            return  respsucc
        elif(sta == 'Failed'):
            respfail = {"responseid": reqData['requestid'], "responsefor":"dbconnectionstring_processdeleteonecond","responseto":"UI","responsedata": {"message":"Delete request Failed"}}
            return  respfail
    else:
        respfail = {"responseid": reqData['requestid'], "responsefor":"dbconnectionstring_processdeleteonecond","responseto":"UI","responsedata": {"message":"Error in Request"}}
        return  respfail   
    
#1.6. Update One Conditional
def dbconnectionstring_processupdateonecond(reqData):
    if isinstance(reqData, dict):
        data=reqData['requestdata']
        dbconnectionstringname=data["dbconnectionstringname"]
        dbconnectionstringid = data['dbconnectionstringid']
        dbusernameid=data["dbusernameid"]
        dbpasswordid=data["dbpasswordid"]
        dbipaddressid=data["dbipaddressid"]
        dbtypeid=data["dbtypeid"]
        status = data['status']
        updateStatement = "dbconnectionstringname = '{}',dbusernameid={},dbpasswordid={},dbipaddressid={},dbtypeid={},status = '{}'".format(dbconnectionstringname,dbusernameid,dbpasswordid,dbipaddressid,dbtypeid,status)
        condition = "dbconnectionstringid = {}".format(dbconnectionstringid)
        sta = dbilayer.updateValuesIndb('dbconnectionstring', updateStatement, condition)
        print(sta)
        if(sta == "Success"):
            respsucc = {"responseid": reqData['requestid'], "responsefor":"Update data","responsesetto": reqData['requestsrc'],"responsedata": {"message":"Success"}}
            return  respsucc
        elif(sta == 'Failed'):
            respfail = {"responseid": reqData['requestid'], "responsefor":"Update data","responsesetto": reqData['requestsrc'],"responsedata": {"message":"Failed"}}
            return  respfail
    else:
        respfail = {"responseid": reqData['requestid'], "responsefor":"Update data","responsesetto": reqData['requestsrc'],"responsedata": {"message":"Error in Request"}}
        return  respfail

#1.7. Update All
def dbconnectionstring_processupdateall(req):
     pass


## Functions for DBCOUNTRY
# 1.1. Read All without condition
def dbcountry_processreadall(reqData):
    if isinstance(reqData, dict):
        if reqData['requestdata']['dbcountryid'] == "all":
            sta=dbilayer.readallWithoutCondition('dbcountry', '*',tablesdict.dbcountry_table)
            #sta=common.list2dict(sta)
            if (len(sta) >= 1):
                respsucc={"responseid": reqData['requestid'], "responsefor": "Read all", "responsesetto": reqData['requestsrc'], "response": {"message": sta}}
                return respsucc
            else:
                respfail={"responseid": reqData['requestid'], "responsefor": "Read all", "responsesetto": reqData['requestsrc'], "response": {"message": "No data Received!"}}
                return respfail
        else:
            respfail={"responseid": reqData['requestid'], "responsefor": "Read all", "responsesetto": reqData['requestsrc'], "response": {"message": "Some error in request"}}
            return respfail    
    else:
        respfail={"responseid": reqData['requestid'], "responsefor": "Read all", "responsesetto": reqData['requestsrc'], "response": {"message": "Some error in request"}}
        return respfail
    
# 1.2. Read Multiple Conditional
def dbcountry_processreadmanycond(reqData):
    if isinstance(reqData, dict):
        condition_data=reqData['requestdata']
        condition_data = "status = '{}'".format(condition_data["status"])
        sta=dbilayer.readOneWithcondition('dbcountry', '*', condition_data,tablesdict.dbcountry_table)
        if (len(sta) >= 1):
            #sta=common.list2dict(sta)
            respsucc={"responseid": reqData['requestid'], "responsefor": "Read all with condition", "responsesetto": reqData['requestsrc'], "response": {"message": sta}}
            return respsucc
        else:
            respfail={"responseid": reqData['requestid'], "responsefor": "Read all with condition", "responsesetto": reqData['requestsrc'], "response":{"message": "No data received!"}}
            return respfail
    else:
        respfail={"responseid": reqData['requestid'], "responsefor": "Read all with condition", "responsesetto": reqData['requestsrc'], "response": {"message": "Error Encountered"}}
        return respfail
    
# 1.3. Read One Conditional
def dbcountry_processreadonecond(reqData):
    if isinstance(reqData, dict):
        condition_data=reqData['requestdata']
        condition = "dbcountryid = {} AND status = '{}'".format(condition_data["dbcountryid"], condition_data["status"])
        sta=dbilayer.readOneWithcondition('dbcountry','*', condition,tablesdict.dbcountry_table)
        print(sta)
        #sta=common.list2dict(sta)
        if (len(sta) >= 1):
            respsucc={"responseid": reqData['requestid'], "responsefor": "Read one", "responsesetto": reqData['requestsrc'], "response": {"message": sta}}
            return respsucc
        else:
            respfail={"responseid": reqData['requestid'], "responsefor": "Read one", "responsesetto": reqData['requestsrc'], "response": {"message": "No data Received!"}}
            return respfail
    else:
        respfail={"responseid": reqData['requestid'], "responsefor": "Read one", "responsesetto": reqData['requestsrc'], "response": {"message": "Error Encountered"}}
        return respfail    

# 1.4. Create
def dbcountry_processcreate(reqData):
    if isinstance(reqData, dict):
        #data_to_insert, ids_of_stored = generate_unique_ids('pagename','pagelayoutpropid',reqData, 'pagelayoutnprops')
        #print("all stored ids in db", data_to_insert, ids_of_stored)
        data_to_insert = reqData["requestdata"]
        print(data_to_insert)
        data=tuple(data_to_insert.values())
        sta=dbilayer.insertIntoDBWithoutCondition('dbcountry',constants.column_dbcountry_table, data)
        if(sta == "Success"):
            respsucc={"responseid": reqData['requestid'], "responsefor": "Create", "responsesetto": reqData['requestsrc'], "response": {"message": "Success"}}
            return respsucc
        else:
            respfail={"responseid": reqData['requestid'], "responsefor": "Create", "responsesetto": reqData['requestsrc'], "response": {"message": "Some Error in Request"}}
            return respfail
    else:
        respfail={"responseid": reqData['requestid'], "responsefor": "Create", "responsesetto": reqData['requestsrc'], "response": {"message": "Error Encountered"}}
        return respfail
    
 #1.5. Delete One Conditional
def dbcountry_processdeleteonecond(reqData):
    if reqData['requestdata']['dbcountryid']:
        data = reqData['requestdata']['dbcountryid']
        sta = dbilayer.updateValuesIndb('dbcountry',"status ='9'" ,"dbcountryid = {}".format(data))
        print(sta)
        if(sta == "Success"):
            respsucc = {"responseid": reqData['requestid'], "responsefor":"dbcountry_processdeleteonecond","responseto":"UI","responsedata": {"message":"Deleted Successfully"}}
            return  respsucc
        elif(sta == 'Failed'):
            respfail = {"responseid": reqData['requestid'], "responsefor":"dbcountry_processdeleteonecond","responseto":"UI","responsedata": {"message":"Delete request Failed"}}
            return  respfail
    else:
        respfail = {"responseid": reqData['requestid'], "responsefor":"dbcountry_processdeleteonecond","responseto":"UI","responsedata": {"message":"Error in Request"}}
        return  respfail   
    
#1.6. Update One Conditional
def dbcountry_processupdateonecond(reqData):
    if isinstance(reqData, dict):
        data=reqData['requestdata']
        dbcountryname=data["dbcountryname"]
        dbcountryid = data['dbcountryid']
        dbcountrydesc=data["dbcountrydesc"]
        status = data['status']
        updateStatement = "dbcountryname = '{}',dbcountrydesc='{}',status = '{}'".format(dbcountryname,dbcountrydesc,status)
        condition = "dbcountryid = {}".format(dbcountryid)
        sta = dbilayer.updateValuesIndb('dbcountry', updateStatement, condition)
        print(sta)
        if(sta == "Success"):
            respsucc = {"responseid": reqData['requestid'], "responsefor":"Update data","responsesetto": reqData['requestsrc'],"responsedata": {"message":"Success"}}
            return  respsucc
        elif(sta == 'Failed'):
            respfail = {"responseid": reqData['requestid'], "responsefor":"Update data","responsesetto": reqData['requestsrc'],"responsedata": {"message":"Failed"}}
            return  respfail
    else:
        respfail = {"responseid": reqData['requestid'], "responsefor":"Update data","responsesetto": reqData['requestsrc'],"responsedata": {"message":"Error in Request"}}
        return  respfail

#1.7. Update All
def dbcountry_processupdateall(req):
     pass
'''
'''

### Functions for DBCUSTOMER
# 1.1. Read All without condition
def dbcustomer_processreadall(reqData):
    if isinstance(reqData, dict):
        if reqData['requestdata']['dbcustomerid'] == "all":
            sta=dbilayer.readallWithoutCondition('dbcustomer', '*',tablesdict.dbcustomer_table)
            #sta=common.list2dict(sta)
            if (len(sta) >= 1):
                respsucc={"responseid": reqData['requestid'], "responsefor": "Read all", "responsesetto": reqData['requestsrc'], "response": {"message": sta}}
                return respsucc
            else:
                respfail={"responseid": reqData['requestid'], "responsefor": "Read all", "responsesetto": reqData['requestsrc'], "response": {"message": "No data Received!"}}
                return respfail
        else:
            respfail={"responseid": reqData['requestid'], "responsefor": "Read all", "responsesetto": reqData['requestsrc'], "response": {"message": "Some error in request"}}
            return respfail    
    else:
        respfail={"responseid": reqData['requestid'], "responsefor": "Read all", "responsesetto": reqData['requestsrc'], "response": {"message": "Some error in request"}}
        return respfail
    
# 1.2. Read Multiple Conditional
def dbcustomer_processreadmanycond(reqData):
    if isinstance(reqData, dict):
        condition_data=reqData['requestdata']
        condition_data = "status = '{}'".format(condition_data["status"])
        sta=dbilayer.readOneWithcondition('dbcustomer', '*', condition_data,tablesdict.dbcustomer_table)
        if (len(sta) >= 1):
            #sta=common.list2dict(sta)
            respsucc={"responseid": reqData['requestid'], "responsefor": "Read all with condition", "responsesetto": reqData['requestsrc'], "response": {"message": sta}}
            return respsucc
        else:
            respfail={"responseid": reqData['requestid'], "responsefor": "Read all with condition", "responsesetto": reqData['requestsrc'], "response":{"message": "No data received!"}}
            return respfail
    else:
        respfail={"responseid": reqData['requestid'], "responsefor": "Read all with condition", "responsesetto": reqData['requestsrc'], "response": {"message": "Error Encountered"}}
        return respfail
    
# 1.3. Read One Conditional
def dbcustomer_processreadonecond(reqData):
    if isinstance(reqData, dict):
        condition_data=reqData['requestdata']
        condition = "dbcustomerid = {} AND status = '{}'".format(condition_data["dbcustomerid"], condition_data["status"])
        sta=dbilayer.readOneWithcondition('dbcustomer','*', condition,tablesdict.dbcustomer_table)
        print(sta)
        #sta=common.list2dict(sta)
        if (len(sta) >= 1):
            respsucc={"responseid": reqData['requestid'], "responsefor": "Read one", "responsesetto": reqData['requestsrc'], "response": {"message": sta}}
            return respsucc
        else:
            respfail={"responseid": reqData['requestid'], "responsefor": "Read one", "responsesetto": reqData['requestsrc'], "response": {"message": "No data Received!"}}
            return respfail
    else:
        respfail={"responseid": reqData['requestid'], "responsefor": "Read one", "responsesetto": reqData['requestsrc'], "response": {"message": "Error Encountered"}}
        return respfail    

# 1.4. Create
def dbcustomer_processcreate(reqData):
    if isinstance(reqData, dict):
        #data_to_insert, ids_of_stored = generate_unique_ids('pagename','pagelayoutpropid',reqData, 'pagelayoutnprops')
        #print("all stored ids in db", data_to_insert, ids_of_stored)
        data_to_insert = reqData["requestdata"]
        print(data_to_insert)
        data=tuple(data_to_insert.values())
        sta=dbilayer.insertIntoDBWithoutCondition('dbcustomer',constants.column_dbcustomer_table, data)
        if(sta == "Success"):
            respsucc={"responseid": reqData['requestid'], "responsefor": "Create", "responsesetto": reqData['requestsrc'], "response": {"message": "Success"}}
            return respsucc
        else:
            respfail={"responseid": reqData['requestid'], "responsefor": "Create", "responsesetto": reqData['requestsrc'], "response": {"message": "Some Error in Request"}}
            return respfail
    else:
        respfail={"responseid": reqData['requestid'], "responsefor": "Create", "responsesetto": reqData['requestsrc'], "response": {"message": "Error Encountered"}}
        return respfail
    
 #1.5. Delete One Conditional
def dbcustomer_processdeleteonecond(reqData):
    if reqData['requestdata']['dbcustomerid']:
        data = reqData['requestdata']['dbcustomerid']
        sta = dbilayer.updateValuesIndb('dbcustomer',"status ='9'" ,"dbcustomerid = {}".format(data))
        print(sta)
        if(sta == "Success"):
            respsucc = {"responseid": reqData['requestid'], "responsefor":"dbcustomer_processdeleteonecond","responseto":"UI","responsedata": {"message":"Deleted Successfully"}}
            return  respsucc
        elif(sta == 'Failed'):
            respfail = {"responseid": reqData['requestid'], "responsefor":"dbcustomer_processdeleteonecond","responseto":"UI","responsedata": {"message":"Delete request Failed"}}
            return  respfail
    else:
        respfail = {"responseid": reqData['requestid'], "responsefor":"dbcustomer_processdeleteonecond","responseto":"UI","responsedata": {"message":"Error in Request"}}
        return  respfail   
    
#1.6. Update One Conditional
def dbcustomer_processupdateonecond(reqData):
    if isinstance(reqData, dict):
        data=reqData['requestdata']
        dbfirstname=data["dbfirstname"]
        dbcustomerid = data['dbcustomerid']
        dblastname=data["dblastname"]
        dbemailid=data["dbemailid"]
        dbuserid=data["dbuserid"]
        dbaddress=data["dbaddress"]
        dbcreatedate=data["dbcreatedate"]
        dblastupdated=data["dblastupdated"]
        dbplanid=data["dbplanid"]
        status = data['status']
        updateStatement = "dbfirstname = '{}',dblastname='{}',dbemailid={},dbuserid={},dbaddress='{}',dbcreatedate='{}',dblastupdated='{}',dbplanid={},status = '{}'".format(dbfirstname,dblastname,dbemailid,dbuserid,dbaddress,dbcreatedate,dblastupdated,dbplanid,status)
        condition = "dbcustomerid = {}".format(dbcustomerid)
        sta = dbilayer.updateValuesIndb('dbCustomer', updateStatement, condition)
        print(sta)
        if(sta == "Success"):
            respsucc = {"responseid": reqData['requestid'], "responsefor":"Update data","responsesetto": reqData['requestsrc'],"responsedata": {"message":"Success"}}
            return  respsucc
        elif(sta == 'Failed'):
            respfail = {"responseid": reqData['requestid'], "responsefor":"Update data","responsesetto": reqData['requestsrc'],"responsedata": {"message":"Failed"}}
            return  respfail
    else:
        respfail = {"responseid": reqData['requestid'], "responsefor":"Update data","responsesetto": reqData['requestsrc'],"responsedata": {"message":"Error in Request"}}
        return  respfail

#1.7. Update All
def dbcustomer_processupdateall(req):
     pass



## Functions for DBTYPE
# 1.1. Read All without condition
def dbtype_processreadall(reqData):
    if isinstance(reqData, dict):
        if reqData['requestdata']['dbtypeid'] == "all":
            sta=dbilayer.readallWithoutCondition('dbtype', '*',tablesdict.dbtype_table)
            #sta=common.list2dict(sta)
            if (len(sta) >= 1):
                respsucc={"responseid": reqData['requestid'], "responsefor": "Read all", "responsesetto": reqData['requestsrc'], "response": {"message": sta}}
                return respsucc
            else:
                respfail={"responseid": reqData['requestid'], "responsefor": "Read all", "responsesetto": reqData['requestsrc'], "response": {"message": "No data Received!"}}
                return respfail
        else:
            respfail={"responseid": reqData['requestid'], "responsefor": "Read all", "responsesetto": reqData['requestsrc'], "response": {"message": "Some error in request"}}
            return respfail    
    else:
        respfail={"responseid": reqData['requestid'], "responsefor": "Read all", "responsesetto": reqData['requestsrc'], "response": {"message": "Some error in request"}}
        return respfail
    
# 1.2. Read Multiple Conditional
def dbtype_processreadmanycond(reqData):
    if isinstance(reqData, dict):
        condition_data=reqData['requestdata']
        condition_data = "status = '{}'".format(condition_data["status"])
        sta=dbilayer.readOneWithcondition('dbtype', '*', condition_data,tablesdict.dbtype_table)
        if (len(sta) >= 1):
            #sta=common.list2dict(sta)
            respsucc={"responseid": reqData['requestid'], "responsefor": "Read all with condition", "responsesetto": reqData['requestsrc'], "response": {"message": sta}}
            return respsucc
        else:
            respfail={"responseid": reqData['requestid'], "responsefor": "Read all with condition", "responsesetto": reqData['requestsrc'], "response":{"message": "No data received!"}}
            return respfail
    else:
        respfail={"responseid": reqData['requestid'], "responsefor": "Read all with condition", "responsesetto": reqData['requestsrc'], "response": {"message": "Error Encountered"}}
        return respfail
    
# 1.3. Read One Conditional
def dbtype_processreadonecond(reqData):
    if isinstance(reqData, dict):
        condition_data=reqData['requestdata']
        condition = "dbtypeid = {} AND status = '{}'".format(condition_data["dbtypeid"], condition_data["status"])
        sta=dbilayer.readOneWithcondition('dbtype','*', condition,tablesdict.dbtype_table)
        print(sta)
        #sta=common.list2dict(sta)
        if (len(sta) >= 1):
            respsucc={"responseid": reqData['requestid'], "responsefor": "Read one", "responsesetto": reqData['requestsrc'], "response": {"message": sta}}
            return respsucc
        else:
            respfail={"responseid": reqData['requestid'], "responsefor": "Read one", "responsesetto": reqData['requestsrc'], "response": {"message": "No data Received!"}}
            return respfail
    else:
        respfail={"responseid": reqData['requestid'], "responsefor": "Read one", "responsesetto": reqData['requestsrc'], "response": {"message": "Error Encountered"}}
        return respfail    

# 1.4. Create
def dbtype_processcreate(reqData):
    if isinstance(reqData, dict):
        #data_to_insert, ids_of_stored = generate_unique_ids('pagename','pagelayoutpropid',reqData, 'pagelayoutnprops')
        #print("all stored ids in db", data_to_insert, ids_of_stored)
        data_to_insert = reqData["requestdata"]
        print(data_to_insert)
        data=tuple(data_to_insert.values())
        sta=dbilayer.insertIntoDBWithoutCondition('dbtype',constants.column_dbtype_table, data)
        if(sta == "Success"):
            respsucc={"responseid": reqData['requestid'], "responsefor": "Create", "responsesetto": reqData['requestsrc'], "response": {"message": "Success"}}
            return respsucc
        else:
            respfail={"responseid": reqData['requestid'], "responsefor": "Create", "responsesetto": reqData['requestsrc'], "response": {"message": "Some Error in Request"}}
            return respfail
    else:
        respfail={"responseid": reqData['requestid'], "responsefor": "Create", "responsesetto": reqData['requestsrc'], "response": {"message": "Error Encountered"}}
        return respfail
    
 #1.5. Delete One Conditional
def dbtype_processdeleteonecond(reqData):
    if reqData['requestdata']['dbtypeid']:
        data = reqData['requestdata']['dbtypeid']
        sta = dbilayer.updateValuesIndb('dbtype',"status ='9'" ,"dbtypeid = {}".format(data))
        print(sta)
        if(sta == "Success"):
            respsucc = {"responseid": reqData['requestid'], "responsefor":"dbtype_processdeleteonecond","responseto":"UI","responsedata": {"message":"Deleted Successfully"}}
            return  respsucc
        elif(sta == 'Failed'):
            respfail = {"responseid": reqData['requestid'], "responsefor":"dbtype_processdeleteonecond","responseto":"UI","responsedata": {"message":"Delete request Failed"}}
            return  respfail
    else:
        respfail = {"responseid": reqData['requestid'], "responsefor":"dbtype_processdeleteonecond","responseto":"UI","responsedata": {"message":"Error in Request"}}
        return  respfail   
    
#1.6. Update One Conditional
def dbtype_processupdateonecond(reqData):
    if isinstance(reqData, dict):
        data=reqData['requestdata']
        dbtypename=data["dbtypename"]
        dbtypeid = data['dbtypeid']
        dbtypedesc=data["dbtypedesc"]
        dbschemaid=data["dbschemaid"]
        dbcategoryid=data["dbcategoryid"]
        dbinstanceid=data["dbinstanceid"]
        dbnameid=data["dbnameid"]
        status = data['status']
        updateStatement = "dbtypename = '{}',dbtypedesc='{}',dbschemaid={},dbcategoryid={},dbinstanceid={},dbnameid={},status = '{}'".format(dbtypename,dbtypedesc, dbschemaid, dbcategoryid,dbinstanceid,dbnameid,status)
        condition = "dbtypeid = {}".format(dbtypeid)
        sta = dbilayer.updateValuesIndb('dbtype', updateStatement, condition)
        print(sta)
        if(sta == "Success"):
            respsucc = {"responseid": reqData['requestid'], "responsefor":"Update data","responsesetto": reqData['requestsrc'],"responsedata": {"message":"Success"}}
            return  respsucc
        elif(sta == 'Failed'):
            respfail = {"responseid": reqData['requestid'], "responsefor":"Update data","responsesetto": reqData['requestsrc'],"responsedata": {"message":"Failed"}}
            return  respfail
    else:
        respfail = {"responseid": reqData['requestid'], "responsefor":"Update data","responsesetto": reqData['requestsrc'],"responsedata": {"message":"Error in Request"}}
        return  respfail

#1.7. Update All
def dbtype_processupdateall(req):
     pass

## Functions for DBCATEGORY
def dbcategory_processreadall(reqData):
    if isinstance(reqData, dict):
        if reqData['requestdata']['dbcategoryid'] == "all":
            sta=dbilayer.readallWithoutCondition('dbcategory', '*',tablesdict.dbcategory_table)
            #sta=common.list2dict(sta)
            if (len(sta) >= 1):
                respsucc={"responseid": reqData['requestid'], "responsefor": "Read all", "responsesetto": reqData['requestsrc'], "response": {"message": sta}}
                return respsucc
            else:
                respfail={"responseid": reqData['requestid'], "responsefor": "Read all", "responsesetto": reqData['requestsrc'], "response": {"message": "No data Received!"}}
                return respfail
        else:
            respfail={"responseid": reqData['requestid'], "responsefor": "Read all", "responsesetto": reqData['requestsrc'], "response": {"message": "Some error in request"}}
            return respfail    
    else:
        respfail={"responseid": reqData['requestid'], "responsefor": "Read all", "responsesetto": reqData['requestsrc'], "response": {"message": "Some error in request"}}
        return respfail
    
# 1.2. Read Multiple Conditional
def dbcategory_processreadmanycond(reqData):
    if isinstance(reqData, dict):
        condition_data=reqData['requestdata']
        condition_data = "status = '{}'".format(condition_data["status"])
        sta=dbilayer.readOneWithcondition('dbcategory', '*', condition_data,tablesdict.dbcategory_table)
        if (len(sta) >= 1):
            #sta=common.list2dict(sta)
            respsucc={"responseid": reqData['requestid'], "responsefor": "Read all with condition", "responsesetto": reqData['requestsrc'], "response": {"message": sta}}
            return respsucc
        else:
            respfail={"responseid": reqData['requestid'], "responsefor": "Read all with condition", "responsesetto": reqData['requestsrc'], "response":{"message": "No data received!"}}
            return respfail
    else:
        respfail={"responseid": reqData['requestid'], "responsefor": "Read all with condition", "responsesetto": reqData['requestsrc'], "response": {"message": "Error Encountered"}}
        return respfail
    
# 1.3. Read One Conditional
def dbcategory_processreadonecond(reqData):
    if isinstance(reqData, dict):
        condition_data=reqData['requestdata']
        condition = "dbcategoryid = {} AND status = '{}'".format(condition_data["dbcategoryid"], condition_data["status"])
        sta=dbilayer.readOneWithcondition('dbcategory','*', condition,tablesdict.dbcategory_table)
        print(sta)
        #sta=common.list2dict(sta)
        if (len(sta) >= 1):
            respsucc={"responseid": reqData['requestid'], "responsefor": "Read one", "responsesetto": reqData['requestsrc'], "response": {"message": sta}}
            return respsucc
        else:
            respfail={"responseid": reqData['requestid'], "responsefor": "Read one", "responsesetto": reqData['requestsrc'], "response": {"message": "No data Received!"}}
            return respfail
    else:
        respfail={"responseid": reqData['requestid'], "responsefor": "Read one", "responsesetto": reqData['requestsrc'], "response": {"message": "Error Encountered"}}
        return respfail    

# 1.4. Create
def dbcategory_processcreate(reqData):
    if isinstance(reqData, dict):
        #data_to_insert, ids_of_stored = generate_unique_ids('pagename','pagelayoutpropid',reqData, 'pagelayoutnprops')
        #print("all stored ids in db", data_to_insert, ids_of_stored)
        data_to_insert = reqData["requestdata"]
        print(data_to_insert)
        data=tuple(data_to_insert.values())
        sta=dbilayer.insertIntoDBWithoutCondition('dbcategory',constants.column_dbcategory_table, data)
        if(sta == "Success"):
            respsucc={"responseid": reqData['requestid'], "responsefor": "Create", "responsesetto": reqData['requestsrc'], "response": {"message": "Success"}}
            return respsucc
        else:
            respfail={"responseid": reqData['requestid'], "responsefor": "Create", "responsesetto": reqData['requestsrc'], "response": {"message": "Some Error in Request"}}
            return respfail
    else:
        respfail={"responseid": reqData['requestid'], "responsefor": "Create", "responsesetto": reqData['requestsrc'], "response": {"message": "Error Encountered"}}
        return respfail
    
 #1.5. Delete One Conditional
def dbcategory_processdeleteonecond(reqData):
    if reqData['requestdata']['dbcategoryid']:
        data = reqData['requestdata']['dbcategoryid']
        sta = dbilayer.updateValuesIndb('dbcategory',"status ='9'" ,"dbcategoryid = {}".format(data))
        print(sta)
        if(sta == "Success"):
            respsucc = {"responseid": reqData['requestid'], "responsefor":"dbcategory_processdeleteonecond","responseto":"UI","responsedata": {"message":"Deleted Successfully"}}
            return  respsucc
        elif(sta == 'Failed'):
            respfail = {"responseid": reqData['requestid'], "responsefor":"dbcategory_processdeleteonecond","responseto":"UI","responsedata": {"message":"Delete request Failed"}}
            return  respfail
    else:
        respfail = {"responseid": reqData['requestid'], "responsefor":"dbcategory_processdeleteonecond","responseto":"UI","responsedata": {"message":"Error in Request"}}
        return  respfail   
    
#1.6. Update One Conditional
def dbcategory_processupdateonecond(reqData):
    if isinstance(reqData, dict):
        data=reqData['requestdata']
        dbcategoryname=data["dbcategoryname"]
        dbcategoryid = data['dbcategoryid']
        dbschemaid=data["dbschemaid"]
        dbcategorydesc=data["dbcategorydesc"]
        status = data['status']
        updateStatement = "dbcategoryname = '{}',dbschemaid={},dbcategorydesc='{}',status = '{}'".format(dbcategoryname,dbschemaid,dbcategorydesc,status)
        condition = "dbcategoryid = {}".format(dbcategoryid)
        sta = dbilayer.updateValuesIndb('dbcategory', updateStatement, condition)
        print(sta)
        if(sta == "Success"):
            respsucc = {"responseid": reqData['requestid'], "responsefor":"Update data","responsesetto": reqData['requestsrc'],"responsedata": {"message":"Success"}}
            return  respsucc
        elif(sta == 'Failed'):
            respfail = {"responseid": reqData['requestid'], "responsefor":"Update data","responsesetto": reqData['requestsrc'],"responsedata": {"message":"Failed"}}
            return  respfail
    else:
        respfail = {"responseid": reqData['requestid'], "responsefor":"Update data","responsesetto": reqData['requestsrc'],"responsedata": {"message":"Error in Request"}}
        return  respfail

#1.7. Update All
def dbcategory_processupdateall(req):
     pass








## Functions for DBVARIABLETYPE
def dbvariabletype_processreadall(reqData):
    if isinstance(reqData, dict):
        if reqData['requestdata']['dbvariabletypeid'] == "all":
            sta=dbilayer.readallWithoutCondition('dbvariabletype', '*',tablesdict.dbvariabletype_table)
            #sta=common.list2dict(sta)
            if (len(sta) >= 1):
                respsucc={"responseid": reqData['requestid'], "responsefor": "Read all", "responsesetto": reqData['requestsrc'], "response": {"message": sta}}
                return respsucc
            else:
                respfail={"responseid": reqData['requestid'], "responsefor": "Read all", "responsesetto": reqData['requestsrc'], "response": {"message": "No data Received!"}}
                return respfail
        else:
            respfail={"responseid": reqData['requestid'], "responsefor": "Read all", "responsesetto": reqData['requestsrc'], "response": {"message": "Some error in request"}}
            return respfail    
    else:
        respfail={"responseid": reqData['requestid'], "responsefor": "Read all", "responsesetto": reqData['requestsrc'], "response": {"message": "Some error in request"}}
        return respfail
    
# 1.2. Read Multiple Conditional
def dbvariabletype_processreadmanycond(reqData):
    if isinstance(reqData, dict):
        condition_data=reqData['requestdata']
        condition_data = "status = '{}'".format(condition_data["status"])
        sta=dbilayer.readOneWithcondition('dbvariabletype', '*', condition_data,tablesdict.dbvariabletype_table)
        if (len(sta) >= 1):
            #sta=common.list2dict(sta)
            respsucc={"responseid": reqData['requestid'], "responsefor": "Read all with condition", "responsesetto": reqData['requestsrc'], "response": {"message": sta}}
            return respsucc
        else:
            respfail={"responseid": reqData['requestid'], "responsefor": "Read all with condition", "responsesetto": reqData['requestsrc'], "response":{"message": "No data received!"}}
            return respfail
    else:
        respfail={"responseid": reqData['requestid'], "responsefor": "Read all with condition", "responsesetto": reqData['requestsrc'], "response": {"message": "Error Encountered"}}
        return respfail
    
# 1.3. Read One Conditional
def dbvariabletype_processreadonecond(reqData):
    if isinstance(reqData, dict):
        condition_data=reqData['requestdata']
        condition = "dbvariabletypeid = {} AND status = '{}'".format(condition_data["dbvariabletypeid"], condition_data["status"])
        sta=dbilayer.readOneWithcondition('dbvariabletype','*', condition,tablesdict.dbvariabletype_table)
        print(sta)
        #sta=common.list2dict(sta)
        if (len(sta) >= 1):
            respsucc={"responseid": reqData['requestid'], "responsefor": "Read one", "responsesetto": reqData['requestsrc'], "response": {"message": sta}}
            return respsucc
        else:
            respfail={"responseid": reqData['requestid'], "responsefor": "Read one", "responsesetto": reqData['requestsrc'], "response": {"message": "No data Received!"}}
            return respfail
    else:
        respfail={"responseid": reqData['requestid'], "responsefor": "Read one", "responsesetto": reqData['requestsrc'], "response": {"message": "Error Encountered"}}
        return respfail    

# 1.4. Create
def dbvariabletype_processcreate(reqData):
    if isinstance(reqData, dict):
        #data_to_insert, ids_of_stored = generate_unique_ids('pagename','pagelayoutpropid',reqData, 'pagelayoutnprops')
        #print("all stored ids in db", data_to_insert, ids_of_stored)
        data_to_insert = reqData["requestdata"]
        print(data_to_insert)
        data=tuple(data_to_insert.values())
        sta=dbilayer.insertIntoDBWithoutCondition('dbvariabletype',constants.column_dbvariabletype_table, data)
        if(sta == "Success"):
            respsucc={"responseid": reqData['requestid'], "responsefor": "Create", "responsesetto": reqData['requestsrc'], "response": {"message": "Success"}}
            return respsucc
        else:
            respfail={"responseid": reqData['requestid'], "responsefor": "Create", "responsesetto": reqData['requestsrc'], "response": {"message": "Some Error in Request"}}
            return respfail
    else:
        respfail={"responseid": reqData['requestid'], "responsefor": "Create", "responsesetto": reqData['requestsrc'], "response": {"message": "Error Encountered"}}
        return respfail
    
 #1.5. Delete One Conditional
def dbvariabletype_processdeleteonecond(reqData):
    if reqData['requestdata']['dbvariabletypeid']:
        data = reqData['requestdata']['dbvariabletypeid']
        sta = dbilayer.updateValuesIndb('dbvariabletype',"status ='9'" ,"dbvariabletypeid = {}".format(data))
        print(sta)
        if(sta == "Success"):
            respsucc = {"responseid": reqData['requestid'], "responsefor":"dbcategory_processdeleteonecond","responseto":"UI","responsedata": {"message":"Deleted Successfully"}}
            return  respsucc
        elif(sta == 'Failed'):
            respfail = {"responseid": reqData['requestid'], "responsefor":"dbcategory_processdeleteonecond","responseto":"UI","responsedata": {"message":"Delete request Failed"}}
            return  respfail
    else:
        respfail = {"responseid": reqData['requestid'], "responsefor":"dbcategory_processdeleteonecond","responseto":"UI","responsedata": {"message":"Error in Request"}}
        return  respfail   
    
#1.6. Update One Conditional
def dbvariabletype_processupdateonecond(reqData):
    if isinstance(reqData, dict):
        data=reqData['requestdata']
        dbvariabletypename=data["dbvariabletypename"]
        dbvariabletypeid = data['dbvariabletypeid']
        status = data['status']
        updateStatement = "dbvariabletypename = '{}', status = '{}'".format(dbvariabletypename,status)
        condition = "dbvariabletypeid = {}".format(dbvariabletypeid)
        sta = dbilayer.updateValuesIndb('dbvariabletype', updateStatement, condition)
        print(sta)
        if(sta == "Success"):
            respsucc = {"responseid": reqData['requestid'], "responsefor":"Update data","responsesetto": reqData['requestsrc'],"responsedata": {"message":"Success"}}
            return  respsucc
        elif(sta == 'Failed'):
            respfail = {"responseid": reqData['requestid'], "responsefor":"Update data","responsesetto": reqData['requestsrc'],"responsedata": {"message":"Failed"}}
            return  respfail
    else:
        respfail = {"responseid": reqData['requestid'], "responsefor":"Update data","responsesetto": reqData['requestsrc'],"responsedata": {"message":"Error in Request"}}
        return  respfail

#1.7. Update All
def dbvariabletype_processupdateall(req):
     pass