5586 lines
305 KiB
Plaintext
5586 lines
305 KiB
Plaintext
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']
|
|
status = reqData['requestdata']['status']
|
|
print(data)
|
|
print(status)
|
|
print()
|
|
print()
|
|
print()
|
|
print()
|
|
sta = dbilayer.updateValuesIndb('dbacl',"status = '9'" ,"dbaclid = {} AND status = '{}'".format(data,status))
|
|
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 = {} AND status='{}'".format(dbaclid, status)
|
|
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 = '"+ 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 = "dbauthid = '{}',dbauthdesc = '{}',status = '{}'".format(dbuserid,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='","'.join(data_to_insert.values())
|
|
data = data.replace('"',"'")
|
|
data="'" + data + "'"
|
|
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 = '"+ 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 = '{}', dbusagelimitid = '{}', dbschemaid='{}', dborganizationid = '{}', dbroleid = '{}', dbplanid = '{}', dbusagelimitmax = '{}', status = '{}'".format(dbusagelimitmin,dbusagelimitid,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='","'.join(data_to_insert.values())
|
|
data = data.replace('"',"'")
|
|
data="'" + data + "'"
|
|
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 = '"+ 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 = '{}', dbusernameid = '{}', dbusernamedesc='{}', dbnameid = '{}', dbcategoryid = '{}', status = '{}'".format(dbusername,dbusernameid,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='","'.join(data_to_insert.values())
|
|
data = data.replace('"',"'")
|
|
data="'" + data + "'"
|
|
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 = '"+ 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 = '{}', dbuacid = '{}', dbroleid='{}', dbuacname = '{}',status = '{}'".format(dbuactype,dbuacid,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='","'.join(data_to_insert.values())
|
|
data = data.replace('"',"'")
|
|
data="'" + data + "'"
|
|
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 = '"+ 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 = '{}', dbstateid = '{}', dbcountryid='{}', dbstatedesc = '{}',status = '{}'".format(dbstatename,dbstateid,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='","'.join(data_to_insert.values())
|
|
data = data.replace('"',"'")
|
|
data="'" + data + "'"
|
|
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 = '"+ 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['dbdeleetnotename']
|
|
dbdeletenoteid = data['dbdeletenoteid']
|
|
dbdeletenotedesc = data['dbdeletenotedesc']
|
|
status = data['status']
|
|
updateStatement = "dbdeleetnotename = '{}',dbdeletenoteid = '{}',dbdeletenotedesc = '{}',status = '{}'".format(dbdeletenotename,dbdeletenoteid,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='","'.join(data_to_insert.values())
|
|
data = data.replace('"',"'")
|
|
data="'" + data + "'"
|
|
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 = '"+ 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 = '{}',dbschemaid = '{}',dbschemadesc = '{}',dbcollectionid = '{}', dbauthid = '{}', dbencodingid = '{}', dbvariabletypeid = '{}', status = '{}'".format(dbschemaname,dbschemaid,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('dbDeploye', '*',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('dbDeploye', '*', 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('dbDeploye', '*', 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='","'.join(data_to_insert.values())
|
|
data = data.replace('"',"'")
|
|
data="'" + data + "'"
|
|
sta=dbilayer.insertIntoDBWithoutCondition('dbDeploye',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('dbDeploye',"status ='9'" ,"dbdeployid = '"+ 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 = '{}',dbdeployid = '{}',dbbillingid = '{}',status = '{}'".format(dbdeployname,dbdeployid,dbbillingid,status)
|
|
condition = "dbdeployid = '{}'".format(dbdeployid)
|
|
sta = dbilayer.updateValuesIndb('dbDeploye', 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='","'.join(data_to_insert.values())
|
|
data = data.replace('"',"'")
|
|
data="'" + data + "'"
|
|
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 = '"+ 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 = '{}',dbemailid = '{}',status = '{}'".format(dbemail,dbemailid,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='","'.join(data_to_insert.values())
|
|
data = data.replace('"',"'")
|
|
data="'" + data + "'"
|
|
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 = '"+ 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 = '{}',dbencodingid = '{}',dbencodingname = '{}',status = '{}'".format(dbencodingdesc,dbencodingid, 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='","'.join(data_to_insert.values())
|
|
data = data.replace('"',"'")
|
|
data="'" + data + "'"
|
|
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 = '"+ 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 = "dbgeninvoiceid = '{}',dbgeninvoicetype = '{}',dbinvoiceid = '{}',status = '{}'".format(dbgeninvoiceid,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='","'.join(data_to_insert.values())
|
|
data = data.replace('"',"'")
|
|
data="'" + data + "'"
|
|
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 = '"+ 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 = '{}',dbgstid = '{}',status = '{}'".format(dbgstnumber,dbgstid,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='","'.join(data_to_insert.values())
|
|
data = data.replace('"',"'")
|
|
data="'" + data + "'"
|
|
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 = '"+ 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 = '{}',dbhashid = '{}',dbhashtype = '{}',status = '{}'".format(dbhashname,dbhashid,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='","'.join(data_to_insert.values())
|
|
data = data.replace('"',"'")
|
|
data="'" + data + "'"
|
|
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 = '"+ 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 = '{}',dbinstanceid= '{}',dbportid= '{}',dbipaddressid= '{}',dbusernameid= '{}',dbpasswordid = '{}',dbschemaid = '{}',status = '{}'".format(dbinstancename,dbinstanceid,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='","'.join(data_to_insert.values())
|
|
data = data.replace('"',"'")
|
|
data="'" + data + "'"
|
|
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 = '"+ 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 = '{}',dbinvoiceid= '{}',dbinvoiceperiodstartdate= '{}',dbinvoicelineitemid= '{}',dbcustomerid= '{}', dbinvoicedate= '{}',dbinvoiceperiodenddate = '{}',dbchargeid= '{}',status = '{}'".format(dbinvoicenumber,dbinvoiceid,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='","'.join(data_to_insert.values())
|
|
data = data.replace('"',"'")
|
|
data="'" + data + "'"
|
|
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 = '"+ 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 = '{}',dbinvoicelineitemid= '{}',status = '{}'".format(dbinvoicelineitemname,dbinvoicelineitemid,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='","'.join(data_to_insert.values())
|
|
data = data.replace('"',"'")
|
|
data="'" + data + "'"
|
|
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 = '"+ 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= '{}',dbipaddressid= '{}',dbipaddressdesc= '{}',dbusernameid= '{}',dbpasswordid= '{}',status = '{}'".format(dbipaddressvalue,dbipaddressid,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='","'.join(data_to_insert.values())
|
|
data = data.replace('"',"'")
|
|
data="'" + data + "'"
|
|
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 = '"+ 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= '{}',dbkycid= '{}',dbtypeid '{}',status = '{}'".format(dbkycdesc,dbkycid,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='","'.join(data_to_insert.values())
|
|
data = data.replace('"',"'")
|
|
data="'" + data + "'"
|
|
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 = '"+ 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= '{}',dbnameid= '{}',dbschemaid '{}',dbcategoryid '{}',status = '{}'".format(dbname,dbnameid,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='","'.join(data_to_insert.values())
|
|
data = data.replace('"',"'")
|
|
data="'" + data + "'"
|
|
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 = '"+ 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 = "dborderid= '{}',dbordername= '{}',dbbillingid= '{}',dbpackageid = '{}',status = '{}'".format(dbordersid,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='","'.join(data_to_insert.values())
|
|
data = data.replace('"',"'")
|
|
data="'" + data + "'"
|
|
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 = '"+ 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= '{}',dborganizationid= '{}',dborganizationdesc='{}',dbpanid= '{}',status = '{}'".format(dborganizationname,dborganizationid,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='","'.join(data_to_insert.values())
|
|
data = data.replace('"',"'")
|
|
data="'" + data + "'"
|
|
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 = '"+ 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= '{}',dbpackageid= '{}',status = '{}'".format(dbpackagename,dbpackageid,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='","'.join(data_to_insert.values())
|
|
data = data.replace('"',"'")
|
|
data="'" + data + "'"
|
|
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 = '"+ 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= '{}',dbpanid= '{}',dbemailid= '{}',dbphoneid= '{}',dbkycid= '{}',status = '{}'".format(dbpannumber,dbpanid,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='","'.join(data_to_insert.values())
|
|
data = data.replace('"',"'")
|
|
data="'" + data + "'"
|
|
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 = '"+ 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= '{}',dbpasswordid= '{}',dbpassworddesc= '{}',dbusernameid= '{}',dbcategoryid= '{}',status = '{}'".format(dbpassword,dbpasswordid,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='","'.join(data_to_insert.values())
|
|
data = data.replace('"',"'")
|
|
data="'" + data + "'"
|
|
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 = '"+ 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= '{}',dbpermissionid= '{}',dbtypeid= '{}',dbaclid= '{}',status = '{}'".format(dbpermissionname,dbpermissionid,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='","'.join(data_to_insert.values())
|
|
data = data.replace('"',"'")
|
|
data="'" + data + "'"
|
|
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 = '"+ 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= '{}',dbphoneid= '{}',status = '{}'".format(dbphonenumber,dbphoneid,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='","'.join(data_to_insert.values())
|
|
data = data.replace('"',"'")
|
|
data="'" + data + "'"
|
|
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 = '"+ 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= '{}',dbpincodeid= '{}',dbcityid= '{}',dbstateid= '{}',dbcountryid= '{}',status = '{}'".format(dbpincode,dbpincodeid,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='","'.join(data_to_insert.values())
|
|
data = data.replace('"',"'")
|
|
data="'" + data + "'"
|
|
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 = '"+ 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= '{}',dbplanid= '{}',status = '{}'".format(dbplanname,dbplanid,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='","'.join(data_to_insert.values())
|
|
data = data.replace('"',"'")
|
|
data="'" + data + "'"
|
|
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 = '"+ 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= '{}',dbplanbillingid= '{}',dbpackageid= '{}',dbplanid= '{}',status = '{}'".format(dbplanbillingname,dbplanbillingid,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='","'.join(data_to_insert.values())
|
|
data = data.replace('"',"'")
|
|
data="'" + data + "'"
|
|
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 = '"+ 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 = "dbplansid= '{}',dbplansname= '{}',dbtypeid= '{}',dbbillingid= '{}',status = '{}'".format(dbplansid,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='","'.join(data_to_insert.values())
|
|
data = data.replace('"',"'")
|
|
data="'" + data + "'"
|
|
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 = '"+ 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= '{}',dbpoid= '{}',dbinvoiceid= '{}',dbbillingid= '{}',dbcustomerid= '{}',dborganizationid= '{}',status = '{}'".format(dbponumber,dbpoid,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='","'.join(data_to_insert.values())
|
|
data = data.replace('"',"'")
|
|
data="'" + data + "'"
|
|
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 = '"+ 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= '{}',dbportid= '{}',dbportnumbercategory= '{}',dbportnumberdesc= '{}',dbcountryid= '{}',dbpincodeid= '{}',dbusernameid= '{}',dbpasswordid= '{}',status = '{}'".format(dbportnumbername,dbportid,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='","'.join(data_to_insert.values())
|
|
data = data.replace('"',"'")
|
|
data="'" + data + "'"
|
|
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 = '"+ 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= '{}',dbprodid= '{}',status = '{}'".format(dbprodname,dbprodid,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='","'.join(data_to_insert.values())
|
|
data = data.replace('"',"'")
|
|
data="'" + data + "'"
|
|
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 = '"+ 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= '{}',dbroleid= '{}',dbuserid= '{}',dbroledesc= '{}',dbpermissionid= '{}',status = '{}'".format(dbrolename,dbroleid,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"])
|
|
sta=dbilayer.readOneWithcondition('dbBilling', '*', condition_data,tablesdict.dbbilling_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 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='","'.join(data_to_insert.values())
|
|
data = data.replace('"',"'")
|
|
data="'" + data + "'"
|
|
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 = '"+ 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 = '{}',dbbillingid = '{}',dbcustomerid='{}',amount = '{}',dbbillingdate='{}',dbbillinglastupdate='{}',dbinvoiceid='{}',status = '{}'".format(dbbillingname,dbbillingid,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='","'.join(data_to_insert.values())
|
|
data = data.replace('"',"'")
|
|
data="'" + data + "'"
|
|
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 = '"+ 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 = '{}',dbchargeid = '{}',dbschemaid='{}',status = '{}'".format(dbchargename,dbchargeid,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='","'.join(data_to_insert.values())
|
|
data = data.replace('"',"'")
|
|
data="'" + data + "'"
|
|
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 = '"+ 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 = '{}',dbcollectionid = '{}',status = '{}'".format(dbcollectionname,dbcollectionid,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='","'.join(data_to_insert.values())
|
|
data = data.replace('"',"'")
|
|
data="'" + data + "'"
|
|
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 = '"+ 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 = '{}',dbconnectionstringid = '{}',dbusernameid='{}',dbpasswordid='{}',dbipaddressid='{}',dbtypeid='{}',status = '{}'".format(dbconnectionstringname,dbconnectionstringid,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='","'.join(data_to_insert.values())
|
|
data = data.replace('"',"'")
|
|
data="'" + data + "'"
|
|
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 = '"+ 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 = '{}',dbcountryid = '{}',dbcountrydesc='{}',status = '{}'".format(dbcountryname,dbcountryid,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='","'.join(data_to_insert.values())
|
|
data = data.replace('"',"'")
|
|
data="'" + data + "'"
|
|
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 = '"+ 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 = '{}',dbcustomerid = '{}',dblastname='{}',dbemailid='{}',dbuserid='{}',dbaddress='{}',dbcreatedate='{}',dblastupdated='{}',dbplanid='{}',status = '{}'".format(dbfirstname,dbcustomerid,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='","'.join(data_to_insert.values())
|
|
data = data.replace('"',"'")
|
|
data="'" + data + "'"
|
|
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 = '"+ 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 = '{}',dbtypeid = '{}',dbtypedesc='{}',dbschemaid='{}',dbcategoryid='{}',dbinstanceid='{}',dbnameid='{}',status = '{}'".format(dbtypename,dbtypeid,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='","'.join(data_to_insert.values())
|
|
data = data.replace('"',"'")
|
|
data="'" + data + "'"
|
|
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 = '"+ 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 = '{}',dbcategoryid = '{}',dbschemaid='{}',dbcategorydesc='{}',status = '{}'".format(dbcategoryname,dbcategoryid,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
|
|
|
|
|
|
|
|
'''
|
|
COPY dbacl TO 'dbacl.csv' WITH HEADER=true;
|
|
COPY dbauth TO 'dbauth.csv' WITH HEADER=true;
|
|
COPY dbbilling TO 'dbbilling.csv' WITH HEADER=true;
|
|
COPY dbcategory TO 'dbcategory.csv' WITH HEADER=true;
|
|
COPY dbcharges TO 'dbcharges.csv' WITH HEADER=true;
|
|
COPY dbcity TO 'dbcity.csv' WITH HEADER=true;
|
|
COPY dbcollection TO 'dbcollection.csv' WITH HEADER=true;
|
|
COPY dbconnectionstring TO 'dbconnectionstring.csv' WITH HEADER=true;
|
|
COPY dbcountry TO 'dbcountry.csv' WITH HEADER=true;
|
|
COPY dbcustomer TO 'dbcustomer.csv' WITH HEADER=true;
|
|
COPY dbdeletenote TO 'dbdeletenote.csv' WITH HEADER=true;
|
|
COPY dbdeploy TO 'dbdeploycsv' WITH HEADER=true;
|
|
COPY dbemail TO 'dbemail.csv' WITH HEADER=true;
|
|
COPY dbencoding TO 'dbencoding.csv' WITH HEADER=true;
|
|
COPY dbgeninvoice TO 'dbgeninvoice.csv' WITH HEADER=true;
|
|
COPY dbgst TO 'dbgst.csv' WITH HEADER=true;
|
|
COPY dbhash TO 'dbhash.csv' WITH HEADER=true;
|
|
COPY dbinstance TO 'dbinstance.csv' WITH HEADER=true;
|
|
COPY dbinvoice TO 'dbinvoice.csv' WITH HEADER=true;
|
|
COPY dbinvoicelineitem TO 'dbinvoicelineitem.csv' WITH HEADER=true;
|
|
COPY dbipaddress TO 'dbipaddress.csv' WITH HEADER=true;
|
|
COPY dbkyc TO 'dbkyc.csv' WITH HEADER=true;
|
|
COPY dbname TO 'dbname.csv' WITH HEADER=true;
|
|
COPY dborders TO 'dborders.csv' WITH HEADER=true;
|
|
COPY dborganization TO 'dborganization.csv' WITH HEADER=true;
|
|
COPY dbpackage TO 'dbpackage.csv' WITH HEADER=true;
|
|
COPY dbpan TO 'dbpan.csv' WITH HEADER=true;
|
|
COPY dbpassword TO 'dbpassword.csv' WITH HEADER=true;
|
|
COPY dbpermission TO 'dbpermission.csv' WITH HEADER=true;
|
|
COPY dbphone TO 'dbphone.csv' WITH HEADER=true;
|
|
COPY dbpincode TO 'dbpincode.csv' WITH HEADER=true;
|
|
COPY dbplan TO 'dbplan.csv' WITH HEADER=true;
|
|
COPY dbplanbilling TO 'dbplanbilling.csv' WITH HEADER=true;
|
|
COPY dbplans TO 'dbplans.csv' WITH HEADER=true;
|
|
COPY dbpo TO 'dbpo.csv' WITH HEADER=true;
|
|
COPY dbportnumber TO 'dbportnumber.csv' WITH HEADER=true;
|
|
COPY dbprod TO 'dbprod.csv' WITH HEADER=true;
|
|
COPY dbrole TO 'dbrole.csv' WITH HEADER=true;
|
|
COPY dbschema TO 'dbschema.csv' WITH HEADER=true;
|
|
COPY dbstate TO 'dbstate.csv' WITH HEADER=true;
|
|
COPY dbtype TO 'dbtype.csv' WITH HEADER=true;
|
|
COPY dbuac TO 'uac.csv' WITH HEADER=true;
|
|
COPY dbusagelimit TO 'dbusagelimit.csv' WITH HEADER=true;
|
|
COPY dbusername TO 'dbusername.csv' WITH HEADER=true;
|
|
COPY dbusers TO 'dbusers.csv' WITH HEADER=true;
|
|
COPY dbvariabletype TO 'dbvariabletype.csv' WITH HEADER=true;
|
|
|
|
'''
|