5574 lines
305 KiB
Python
5574 lines
305 KiB
Python
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 |