def login(self, msg, tableName, fileds, dbConfig, sessionkey):
val = False
try:
username = msg["userName"]
password = msg["password"]
#username.replace(" ","")
condition = {"username": username}
dbagent = DatabaseAgent(dbConfig[0], dbConfig[1], "127.0.0.1",
dbConfig[2], dbConfig[3])
dbagent.initConnection()
value = dbagent.fetchData(tableName, fileds, condition)
print("totals...", value)
salt = bytes(value[0][1])
print("sal.....................", salt)
hashPassword = hashlib.sha512(password.encode() + salt).hexdigest()
print("databse hash value", bytes(value[0][0]))
print("hashedpassword", hashPassword.encode())
sign = []
if hashPassword.encode() == bytes(value[0][0]):
val = True
sessionMange.session[sessionkey] = {}
sessionMange.session[sessionkey]["userid"] = (value[0][2])
sessionMange.session[sessionkey]["userrole"] = (value[0][3])
sign_key = nacl.signing.SigningKey.generate()
verifyKey = sign_key.verify_key
sessionMange.session[sessionkey]["signkey"] = (sign_key)
sessionMange.session[sessionkey]["verifykey"] = (verifyKey)
else:
val = False
return val
except Exception as excp:
print("occured exceptio is ", excp)
def addSites(self, clientId, msgDict, sessionkey):
masterDb = DatabaseAgent(conf.mdbName, conf.muserName, conf.host,
conf.mdbPassword, conf.port)
masterDb.initConnection()
cond = {"clientid": clientId}
dbData = masterDb.fetchData("regusers", ["password"], cond)
password = dbData[0][0]
adminDb = DatabaseAgent(clientId, clientId, conf.host, password, 5432)
adminDb.initConnection()
nameLs = []
valuels = []
try:
for key in msgDict:
nameLs.append(key.lower())
valuels.append(msgDict[key])
if adminDb.pushData("sites", nameLs, valuels):
self.log.logEvent("projectManage", 2,
"project added successfully", clientId,
sessionMange.session[sessionkey]["userid"])
response = {
"Header": {
"status": "success",
"module": "projectManage"
},
"Body": {
"message": "site added sucessfully",
"data": ""
},
"Signature": {
"signature": "",
"Key": ""
}
}
return response
else:
self.log.logEvent("projectManage", 2, "project can't added",
clientId,
sessionMange.session[sessionkey]["userid"])
response = {
"Header": {
"status": "success",
"module": "projectManage"
},
"Body": {
"message": "site can't added",
"data": ""
},
"Signature": {
"signature": "",
"Key": ""
}
}
return response
except Exception as expc:
# self.syslog.eventHandle("projectmanagement","exception","exception on projectManage module",str(expc))
self.log.logEvent(
"projectManage", 3,
" all role permission listed occured " + str(expc), clientId,
sessionMange.session[sessionkey]["userid"])
def editLabourer(self,clientId,msgDict,sessionkey):
masterDb = DatabaseAgent(conf.mdbName,conf.muserName,conf.host,conf.mdbPassword,conf.port)
masterDb.initConnection()
cond = {"clientid":clientId}
dbData = masterDb.fetchData("regusers",["password"],cond)
password = dbData[0][0]
adminDb = DatabaseAgent(clientId, clientId, conf.host,password, 5432)
adminDb.initConnection()
condition = {"labourerid": msgDict["labourerId"]}
changDist = {}
for key in msgDict:
if key == "labourerId":
continue
else:
changDist[key.lower()] = (msgDict[key])
try:
if adminDb.editData("labourer",changDist,condition):
self.log.logEvent("labourerManage",2,"labourer Edited success",clientId,sessionMange.session[sessionkey]["userid"])
response = {"Header":{"status":"success","module":"labourerManage"},"Body":{"message":"labourer edited successfully","data":""},"Signature":{"signature":"","Key":""}}
return response
else:
self.log.logEvent("labourerManage",2,"labourer labourer can't ediot",clientId,sessionMange.session[sessionkey]["userid"])
response = {"Header":{"status":"fail","module":"labourerManage"},"Body":{"message":"labourer canot edited","data":""},"Signature":{"signature":"","Key":""}}
return response
except Exception as expc:
# self.syslog.eventHandle("labourerManage","exception","exception on labourerManage module",str(expc))
self.log.logEvent("labourerManage",2,"occured expection is"+str(expc),clientId,sessionMange.session[sessionkey]["userid"])
def shiftCreation(self,clientId,msgDict,sessionkey):
masterDb = DatabaseAgent(conf.mdbName,conf.muserName,conf.host,conf.mdbPassword,conf.port)
masterDb.initConnection()
cond = {"clientid":clientId}
dbData = masterDb.fetchData("regusers",["password"],cond)
password = dbData[0][0]
adminDb = DatabaseAgent(clientId, clientId, conf.host,password, 5432)
adminDb.initConnection()
nameLs = []
valueLs = []
for key in msgDict:
nameLs.append(key)
valueLs.append(msgDict[key])
curTime = datetime.datetime.now().strftime("%Y-%m-%d %H:%M:%S")
nameLs.append("shiftcreatedon")
valueLs.append(curTime)
reval = False
try:
reval = adminDb.pushData("shift",nameLs,valueLs)
if reval:
self.log.logEvent("shiftManage",2,"labourer shift created successfully",clientId,sessionMange.session[sessionkey]["userid"])
response = {"Header":{"status":"success","module":"ShiftManage"},"Body":{"message":"shift Added successfully","data":""},"Signature":{"signature":"","Key":""}}
return response
else:
self.log.logEvent("shiftManage",2,"labourer shift creation error",clientId,sessionMange.session[sessionkey]["userid"])
response = {"Header":{"status":"fail","module":"ShiftManage"},"Body":{"message":"shift can't created","data":""},"Signature":{"signature":"","Key":""}}
return response
except Exception as expc:
print("oocured exception is",expc)
self.log.logEvent("shiftmanage",2,str(expc),clientId,sessionMange.session[sessionkey]["userid"])
def roleList(self, clientId, sessionkey):
masterDb = DatabaseAgent(conf.mdbName, conf.muserName, conf.host,
conf.mdbPassword, conf.port)
masterDb.initConnection()
cond = {"clientid": clientId}
dbData = masterDb.fetchData("regusers", ["password"], cond)
password = dbData[0][0]
adminDb = DatabaseAgent(clientId, clientId, conf.host, password, 5432)
adminDb.initConnection()
self.log.logEvent("Admin", 2,
"total permission list listed successfully",
clientId, sessionMange.session[sessionkey]["userid"])
try:
responseData = adminDb.fetchData("permission",
["rolename", "roleid"])
response = {
"Header": {
"status": "success",
"module": "admin"
},
"Body": {
"message": "user role list",
"data": responseData
},
"Signature": {
"signature": "",
"Key": ""
}
}
return response
except Exception as expc:
self.log.logEvent("Admin", 0, "occured exception is " + str(expc),
clientId,
sessionMange.session[sessionkey]["userid"])
def publicVerification(self):
dbagent = DatabaseAgent("kunnel", "kunnel", "127.0.0.1", "kunnel123",
"5432")
key = []
cond = {"userid": "1557"}
key.append("PrivateKey")
dbprivatekey = dbagent.fetchData(key, "userkeys", cond)
prvk = base64.b64decode(str(data).encode('utf8'))
print("actual key2", prvk)
def deletSites(self, clientId, msgDict, sessionkey):
masterDb = DatabaseAgent(conf.mdbName, conf.muserName, conf.host,
conf.mdbPassword, conf.port)
masterDb.initConnection()
cond = {"clientid": clientId}
dbData = masterDb.fetchData("regusers", ["password"], cond)
password = dbData[0][0]
adminDb = DatabaseAgent(clientId, clientId, conf.host, password, 5432)
adminDb.initConnection()
delete = " set delete = 'True' where "
try:
if adminDb.updateTable(delete, "sites",
{"siteid": msgDict["siteId"]}):
self.log.logEvent("projectManage", 3,
"project deleted successfully", clientId,
sessionMange.session[sessionkey]["userid"])
response = {
"Header": {
"status": "success",
"module": "projectManage"
},
"Body": {
"message": "site deleted sucessfully",
"data": ""
},
"Signature": {
"signature": "",
"Key": ""
}
}
return response
else:
self.log.logEvent("projectManage", 0, "project can't delete",
clientId,
sessionMange.session[sessionkey]["userid"])
response = {
"Header": {
"status": "fail",
"module": "projectManage"
},
"Body": {
"message": "site can't deleted",
"data": ""
},
"Signature": {
"signature": "",
"Key": ""
}
}
return response
except Exception as expc:
# self.syslog.eventHandle("projectmanagement","exception","exception on projectManage module",str(expc))
self.log.logEvent("projectManage", 3, str(expc), clientId,
sessionMange.session[sessionkey]["userid"])
def deleteRole(self, clientId, msgDict, sessionkey):
masterDb = DatabaseAgent(conf.mdbName, conf.muserName, conf.host,
conf.mdbPassword, conf.port)
masterDb.initConnection()
cond = {"clientid": clientId}
dbData = masterDb.fetchData("regusers", ["password"], cond)
password = dbData[0][0]
adminDb = DatabaseAgent(clientId, clientId, conf.host, password, 5432)
adminDb.initConnection()
delete = " set delete = 'True' where "
condition = {"roleid": msgDict["roleId"]}
try:
if self.adminDb.updateTable(delete, "permission", condition):
self.log.logEvent(
"roleManage", 3,
msgDict["roleId"] + "role deleted successfully", clientId,
sessionMange.session[sessionkey]["userid"])
response = {
"Header": {
"status": "success",
"module": "roleManage"
},
"Body": {
"message": "uerer role deleted successfully",
"data": ""
},
"Signature": {
"signature": "",
"Key": ""
}
}
return response
else:
self.log.logEvent(
"roleManage", 3,
msgDict["roleId"] + "user prmiisson database error",
clientId, sessionMange.session[sessionkey]["userid"])
response = {
"Header": {
"status": "success",
"module": "roleManage"
},
"Body": {
"message": "uerer role canot deleted",
"data": ""
},
"Signature": {
"signature": "",
"Key": ""
}
}
return response
except Exception as expc:
# self.syslog.eventHandle("rolemanagement","exception","exception on rolemanage module",str(expc))
self.log.logEvent(
"roleManage", 3,
" all role permission listed occured " + str(expc), clientId,
sessionMange.session[sessionkey]["userid"])
def decrypt(self, encmsg, pubkey, cond):
dbagent = DatabaseAgent("kunnel", "kunnel", "127.0.0.1", "kunnel123",
"5432")
key = [
"PrivateKey",
]
dbPrivateKey = dbagent.fetchData(key, "userkeys", cond)
utf8PriKey = base64.b64decode(str(dbprivatekey).encode('utf8'))
key_box = libnacl.public.Box(utf8PriKey, pubkey)
dec_mess = key_box.decrypt(encmsg)
plainTxt = str(dec_mess, 'utf-8')
return plainTxt
def listRoles(self, clientId, sessionkey):
masterDb = DatabaseAgent(conf.mdbName, conf.muserName, conf.host,
conf.mdbPassword, conf.port)
masterDb.initConnection()
cond = {"clientid": clientId}
dbData = masterDb.fetchData("regusers", ["password"], cond)
password = dbData[0][0]
adminDb = DatabaseAgent(clientId, clientId, conf.host, password, 5432)
adminDb.initConnection()
permiSdata = []
try:
permiSdata = adminDb.fetchData(
"permission", ["rolename", "roleid", "permissions"])
# out = [item for t in permiSdata for item in t]
print("database value is", permiSdata)
out = []
for t in permiSdata:
out.append(list(t))
# for cnt in range(2,len(out),+3):
print("out", out)
for cnt in range(len(out)):
data = bytes(out[cnt][2])
data1 = data.decode("utf-8")
data2 = str(data1).split('&&')
out[cnt][2] = data2
self.log.logEvent("roleManage", 3,
" all role permission listed successfully",
clientId,
sessionMange.session[sessionkey]["userid"])
response = {
"Header": {
"status": "success",
"module": "roleManage"
},
"Body": {
"message": "uerer role list",
"data": out
},
"Signature": {
"signature": "",
"Key": ""
}
}
return response
except Exception as expc:
# self.syslog.eventHandle("rolemanagement","exception","exception on rolemanage module",str(expc))
self.log.logEvent(
"roleManage", 3,
" all role permission listed occured exception is = " +
str(expc), clientId,
sessionMange.session[sessionkey]["userid"])
def uRolePermissionCheck(self, clientid, apiEndPoint, sessionkey):
if sessionMange.session[sessionkey]["userrole"] == "Admin":
return True
else:
masterDb = DatabaseAgent("kunnel", "kunnel", "127.0.0.1",
"kunnel123", 5432)
masterDb.initConnection()
dblist = []
cond = {"clientid": clientid}
dbData = masterDb.fetchData("regusers", ["password"], cond)
password = dbData[0][0]
adminDb = DatabaseAgent(clientid, clientid, "127.0.0.1", password,
5432)
adminDb.initConnection()
# condition = {"roleid":"role1001"}
condition = {
"rolename": sessionMange.session[sessionkey]["userrole"]
}
dbroleList = adminDb.fetchData("permission", ["permissions"],
condition)
print("dbrolelist", dbroleList)
permissions = (bytes(dbroleList[0][0])).decode("utf-8").split("&&")
print("datas ..", permissions)
if apiEndPoint in permissions:
self.log.logEvent("Communication", 2,
"client permission granted")
return True
else:
self.log.logEvent("Communication", 2, "wrong user access")
return False
# return True
################################################################################testing################################################
# def testing(self):
# dbagent = DatabaseAgent("kunnel", "kunnel", "127.0.0.1", "kunnel123", "5432")
# dbagent.initConnection()
# value = dbagent.fetchData("users",["password","salt"])
# salt = value[0][1]
# print("sal type........",salt)
# # hashPassword = hashlib.sha512(password.encode() + salt.encode()).hexdigest()
# #print("producing hash value",hashPassword)
# print("databse hash value",bytes(value[0][0]))
# auth = Authentication()
# print("reval is....",auth.uRolePermissionCheck("kec136","/user/archieve"))
def encrypt(self, msg, pubkey, cond):
dbagent = DatabaseAgent("kunnel", "kunnel", "127.0.0.1", "kunnel123",
"5432")
key = [
"PrivateKey",
]
dbPrivatekey = dbagent.fetchData(key, "userkeys", cond)
utf8PriKey = base64.b64decode(str(dbPrivatekey).encode('utf8'))
print(type(utf8PriKey))
key_box = libnacl.public.Box(utf8PriKey, pubkey)
messageEncoded = bytes(msg, 'utf-8')
cipher = key_box.encrypt(messageEncoded)
return cipher
def generateKeys(self):
Priva_key = PrivateKey.generate()
authDictkey = ["UserId", "privateKey", "publicKey"]
authDictvalue = []
tablename = "userkeys"
userid = 1557
print("actual key=", Priva_key)
encoPrivateKey = Priva_key.encode(Base64Encoder).decode('utf8')
print("publickey", Priva_key.public_key)
encopubk_key = Priva_key.public_key.encode(Base64Encoder).decode(
'utf8')
authDictvalue.append(userid)
authDictvalue.append(encoPrivateKey)
authDictvalue.append(encopubk_key)
dbagent = DatabaseAgent(conf.mdbName, conf.muserName, conf.host,
conf.mdbPassword, conf.port)
dbagent.pushData(tablename, authDictkey, authDictvalue)
def labouerList(self,clientId,sessionkey):
masterDb = DatabaseAgent(conf.mdbName,conf.muserName,conf.host,conf.mdbPassword,conf.port)
masterDb.initConnection()
cond = {"clientid":clientId}
dbData = masterDb.fetchData("regusers",["password"],cond)
password = dbData[0][0]
adminDb = DatabaseAgent(clientId, clientId, conf.host,password, 5432)
adminDb.initConnection()
try:
labourerData = ["labourername","labourerid","projectname","siteid","labourerclass","shiftid"]
self.log.logEvent("labourerManage",2,"labourer info showed successfully",clientId,sessionMange.session[sessionkey]["userid"])
responseData = adminDb.fetchData("labourer",labourerData )
response = {"Header":{"status":"success","module":"labourerManage"},"Body":{"message":"labourer list","data":responseData},"Signature":{"signature":"","Key":""}}
return response
except Exception as expc:
# self.syslog.eventHandle("labourerManage","exception","exception on labourerManage module",str(expc))
self.log.logEvent("labourerManage",2,"occured expection is"+str(expc),clientId,sessionMange.session[sessionkey]["userid"])
def labourerInfo(self,clientId,msgDict,sessionkey):
masterDb = DatabaseAgent(conf.mdbName,conf.muserName,conf.host,conf.mdbPassword,conf.port)
masterDb.initConnection()
cond = {"clientid":clientId}
dbData = masterDb.fetchData("regusers",["password"],cond)
password = dbData[0][0]
adminDb = DatabaseAgent(clientId, clientId, conf.host,password, 5432)
adminDb.initConnection()
conditiond = {"labourerid":msgDict["labourerId"]}
try:
labourdata = ["labourername","callbyname","gender","dateofbirth","fathername","bloodgroup","nextofkin","contactnumberofnextofkin","mothertounge","addressline1","addressline2","addressline3","village","state","country","pincode" ,"mobilenumber","residancephonenumber","emergencyphonenumber","dateofjoining" ,"migrantworker","designation","projectname" ,"siteid" ,"siteofjoining","labourerclass","shiftid","documenttype","documentnumber","nameasperdoc","bankname","ifsccode","branchname","bankaccountnumber","nameinbank","labourerid"]
self.log.logEvent("labourerManage",2,"labourer info showed successfully",clientId,sessionMange.session[sessionkey]["userid"])
responseData = adminDb.fetchData("labourer",labourdata,conditiond)
response = {"Header":{"status":"success","module":"labourerManage"},"Body":{"message":"labourer info","data":responseData},"Signature":{"signature":"","Key":""}}
return response
except Exception as expc:
# self.syslog.eventHandle("labourerManage","exception","exception on labourerManage module",str(expc))
self.log.logEvent("labourerManage",2,"occured expection is"+str(expc),clientId,sessionMange.session[sessionkey]["userid"])
def bankInfo(self,clientId,msgDict,sessionkey):
masterDb = DatabaseAgent(conf.mdbName,conf.muserName,conf.host,conf.mdbPassword,conf.port)
masterDb.initConnection()
cond = {"clientid":clientId}
dbData = masterDb.fetchData("regusers",["password"],cond)
password = dbData[0][0]
adminDb = DatabaseAgent(clientId, clientId, conf.host,password, 5432)
adminDb.initConnection()
conditiond = {"labourerid":msgDict["labourerId"]}
try:
bankdata = ["bankname","ifsccode","branchname","bankaccountnumber","nameinbank"]
self.log.logEvent("labourerManage",2,"labourer info showed successfully",clientId,sessionMange.session[sessionkey]["userid"])
responseData = adminDb.fetchData("labourer",bankdata,conditiond)
response = {"Header":{"status":"success","module":"labourerManage"},"Body":{"message":"labourer info","data":responseData},"Signature":{"signature":"","Key":""}}
return response
except Exception as expc:
# self.syslog.eventHandle("labourerManage","exception","exception on labourerManage module",str(expc))
self.log.logEvent("labourerManage",2,"occured expection is"+str(expc),clientId,sessionMange.session[sessionkey]["userid"])
def classList(self,clientId,sessionkey):
masterDb = DatabaseAgent(conf.mdbName,conf.muserName,conf.host,conf.mdbPassword,conf.port)
masterDb.initConnection()
cond = {"clientid":clientId}
dbData = masterDb.fetchData("regusers",["password"],cond)
password = dbData[0][0]
adminDb = DatabaseAgent(clientId, clientId, conf.host,password, 5432)
adminDb.initConnection()
labclas = ["labourerclass","wageclass","labourerclassid","compensation","retention","advance","concretecharges"] #,"compensation","Retention","Advance","Concrete_charges"]
self.log.logEvent("Admin",2,"class list listed successfully",clientId,sessionMange.session[sessionkey]["userid"])
try:
responseData = adminDb.fetchData("labourerclass",labclas)
response = {"Header":{"status":"success","module":"labourerClass"},"Body":{"message":"class list","data":responseData},"Signature":{"signature":"","Key":""}}
return response
except Exception as expc:
# self.syslog.eventHandle("labourerclassManage","exception","exception on labourerclassManage module",str(expc))
self.log.logEvent("labourerclassManage",2,"occured expection is"+str(expc),clientId,sessionMange.session[sessionkey]["userid"])
def requstApprove(self,clientId,msgDist,sessionkey):
masterdb = DatabaseAgent(conf.mdbName,conf.muserName,conf.host,conf.mdbPassword,conf.port)
masterdb.initConnection()
dbpass = masterdb.fetchData("regusers",["password"],{"clientid":clientId})
password = dbpass[0][0]
admindb = DatabaseAgent(clientId,clientId,conf.host,password,conf.port)
admindb.initConnection()
randomid = str(random.randint(10000000000,1000000000000))[:8]
approveCont = " set approvestatus = 'approved', approveid = "+randomid+" where "
try:
if admindb.updateTable(approveCont,"accountinfo",{"labourerid":msgDist["labourerId"]}):
response = {"Header":{"status":"success","module":"labfinace"},"Body":{"message":"labourer requst is approved","data":""},"Signature":{"signature":"","Key":""}}
return response
else:
response = {"Header":{"status":"fail","module":"labfinace"},"Body":{"message":"labourer requst is can't approved","data":""},"Signature":{"signature":"","Key":""}}
return response
except Exception as expc:
# self.syslog.eventHandle("labourerclassManage","exception","exception on labourerclassManage module",str(expc))
self.log.logEvent("labourerclassManage",2,"occured expection is"+str(expc),clientId,sessionMange.session[sessionkey]["userid"])
def shiftList(self,clientId,sessionkey):
masterDb = DatabaseAgent(conf.mdbName,conf.muserName,conf.host,conf.mdbPassword,conf.port)
masterDb.initConnection()
cond = {"clientid":clientId}
dbData = masterDb.fetchData("regusers",["password"],cond)
password = dbData[0][0]
adminDb = DatabaseAgent(clientId, clientId, conf.host,password, 5432)
adminDb.initConnection()
try:
responseData = adminDb.fetchData("shift","*")
self.log.logEvent("shiftmanage",2,"labourer shift list",clientId,sessionMange.session[sessionkey]["userid"])
response = {"Header":{"status":"success","module":"ShiftManage"},"Body":{"message":"shift can't created","data":responseData},"Signature":{"signature":"","Key":""}}
return response
except Exception as expc:
# self.syslog.eventHandle("shiftmanage","exception","exception on shiftManage module",str(expc))
print("oocured exception is",expc)
self.log.logEvent("shiftmanage",2,"labourer shift listed successfully",clientId,sessionMange.session[sessionkey]["userid"])
def getAttendacePers(self, clientId, msgDict, sessionkey):
masterDb = DatabaseAgent("kunnel", "kunnel", "127.0.0.1", "kunnel123",
"5432")
masterDb.initConnection()
cond = {"clientid": clientId}
dbData = masterDb.fetchData("regusers", ["password"], cond)
password = dbData[0][0]
adminDb = DatabaseAgent(clientId, clientId, "127.0.0.1", password,
5432)
adminDb.initConnection()
dataFields = [
"day", "date", "labourerid", "labourername", "labouercategory",
"intime", "outtime", "numberofhours", "overtimeallocated",
"overtimeworked", "shiftid"
]
tableName = "attendance"
condition = {}
try:
for key in msgDict:
condition[key.lower()] = (msgDict[key])
responseData = adminDb.fetchData(tableName, dataFields, condition)
print("dictonary", responseData)
self.log.logEvent("Admin", 2, "attendance listed success fully")
response = {
"Header": {
"status": "success",
"module": "attendance"
},
"Body": {
"message": "filtered attendance",
"data": responseData
},
"Signature": {
"signature": "",
"Key": ""
}
}
return response
except Exception as expc:
# self.syslog.eventHandle("attendanceManage","exception","exception on attendanceManage module",str(expc))
self.log.logEvent(
"attendanceManage", 3,
" all role permission listed occured " + str(expc))
def filterProjects(self, clientId, msgDict, sessionkey):
masterDb = DatabaseAgent(conf.mdbName, conf.muserName, conf.host,
conf.mdbPassword, conf.port)
masterDb.initConnection()
cond = {"clientid": clientId}
dbData = masterDb.fetchData("regusers", ["password"], cond)
password = dbData[0][0]
adminDb = DatabaseAgent(clientId, clientId, conf.host, password, 5432)
adminDb.initConnection()
# condiotion ={"delete ":"False"}
condition = {}
try:
for key in msgDict:
condition[key.lower()] = msgDict(key)
datalis = [
"projectname,projectlocations,projectlabourers,projectid,siteid"
]
self.log.logEvent("projectManage", 0,
"project listed successfully", clientId,
sessionMange.session[sessionkey]["userid"])
responseData = adminDb.fetchData("projects", datalis, condition)
response = {
"Header": {
"status": "success",
"module": "projectManage"
},
"Body": {
"message": "project filterd",
"data": responseData
},
"Signature": {
"signature": "",
"Key": ""
}
}
return response
except Exception as expc:
# self.syslog.eventHandle("projectmanagement","exception","exception on projectManage module",str(expc))
self.log.logEvent(
"projectManage", 3,
" all role permission listed occured " + str(expc), clientId,
sessionMange.session[sessionkey]["userid"])
def advanceRespo(self,clientId,msgDict,sessionkey):
try:
masterdb = DatabaseAgent(conf.mdbName,conf.muserName,conf.host,conf.mdbPassword,conf.port)
masterdb.initConnection()
dbpass = masterdb.fetchData("regusers",["password"],{"clientid":clientId})
password = dbpass[0][0]
admindb = DatabaseAgent(clientId,clientId,conf.host,password,conf.port)
admindb.initConnection()
listAdvance = admindb.fetchData("laboureradvance",["status","advanceid"],{"labourerid":msgDict["labourerId"]})
self.log.logEvent("paymentDesk",2,"advancerespo",clientId,sessionMange.session[sessionkey]["userid"])
response = {"Header":{"status":"success","module":"labourerManage"},"Body":{"message":"labourer requstedAdvance satus check","data":listAdvance},"Signature":{"signature":"","Key":""}}
return response
except Exception as expc:
# self.syslog.eventHandle("labourerManage","exception","exception on labourerManage module",str(expc))
self.log.logEvent("labourerclassManage",2,"occured expection is"+str(expc),clientId,sessionMange.session[sessionkey]["userid"])
print("exception is occured at",str(expc))
# labad = paymentDesk()
# # print("total advance list",labad.requstList("kec166"))
# print("approvelist",labad.requstApprove("kec166",{"labourerId":"lab1001"}))
# # print("approvelist",labad.requstReject("kec166",{"labourerId":"lab1001"}))
def deleteLabourer(self,clientId,msgDict,sessionkey):
masterDb = DatabaseAgent(conf.mdbName,conf.muserName,conf.host,conf.mdbPassword,conf.port)
masterDb.initConnection()
cond = {"clientid":clientId}
dbData = masterDb.fetchData("regusers",["password"],cond)
password = dbData[0][0]
adminDb = DatabaseAgent(clientId, clientId, conf.host,password, 5432)
adminDb.initConnection()
delete = " set delete = 'True' where "
condition = {"labourerid": msgDict["labourerId"]}
try:
if adminDb.updateTable(delete,"labourer",condition):
self.log.logEvent("labourerManage",2,"labourer deleted successfully",clientId,sessionMange.session[sessionkey]["userid"])
response = {"Header":{"status":"success","module":"labourerManage"},"Body":{"message":"labourer deleted successfully","data":""},"Signature":{"signature":"","Key":""}}
return response
else:
self.log.logEvent("labourerManage",2,"labourer deletd successfully",clientId,sessionMange.session[sessionkey]["userid"])
response = {"Header":{"status":"fail","module":"labourerManage"},"Body":{"message":"labouer cant deleted","data":""},"Signature":{"signature":"","Key":""}}
return response
except Exception as expc:
# self.syslog.eventHandle("labourerManage","exception","exception on labourerManage module",str(expc))
self.log.logEvent("labourerManage",2,"occured expection is"+str(expc),clientId,sessionMange.session[sessionkey]["userid"])
def shiftDeleted(self,clientId,msgDict,sessionkey):
masterDb = DatabaseAgent(conf.mdbName,conf.muserName,conf.host,conf.mdbPassword,conf.port)
masterDb.initConnection()
cond = {"clientid":clientId}
dbData = masterDb.fetchData("regusers",["password"],cond)
password = dbData[0][0]
adminDb = DatabaseAgent(clientId, clientId, conf.host,password, 5432)
adminDb.initConnection()
delete = " set delete = 'True' where "
condition = {"shiftid":msgDict["shiftId"]}
reval = False
try:
if adminDb.updateTable(delete,"shift",condition):
self.log.logEvent("shiftManage",2,msgDict["shiftId"]+"labourer shift deleted successfully",clientId,sessionMange.session[sessionkey]["userid"])
response = {"Header":{"status":"success","module":"ShiftManage"},"Body":{"message":"shift deleted succes","data":""},"Signature":{"signature":"","Key":""}}
return response
else:
self.log.logEvent("shiftManage",2,msgDict["shiftId"]+"labourer shift cant deleted",clientId,sessionMange.session[sessionkey]["userid"])
response = {"Header":{"status":"fail","module":"ShiftManage"},"Body":{"message":"shift canot deleted","data":""},"Signature":{"signature":"","Key":""}}
return response
except Exception as expc:
print("oocured exception is",expc)
self.log.logEvent("shiftmanage",2,"labourer shift delete successfully",clientId,sessionMange.session[sessionkey]["userid"])
class Attendance:
def __init__(self):
self.log = Logger()
self.dbobj = DatabaseAgent("kunnel", "kunnel", "127.0.0.1",
"kunnel123", "5432")
self.dbobj.initConnection()
def getAttendace(self): #to be filled from the call site (module launcher)
dataFields = [
"labourerid", "labourername", "labouercategory", "labourertype",
"intime", "outtime", "numberofhours", "overtimeallocated",
"overtimeworked", "siteid", "projectid"
]
tableName = "attendance"
condition = {"siteid": "siteamerica"}
dbattendance = self.dbobj.fetchData(tableName, dataFields, condition)
print("dictonary", dbattendance)
self.log.logEvent("Admin", 2, "attendance listed sucess fully")
return dbattendance
# atten = Attendance()
# print("attandence",atten.getAttendace())
def projectIdList(self, clientId, sessionkey):
masterDb = DatabaseAgent(conf.mdbName, conf.muserName, conf.host,
conf.mdbPassword, conf.port)
masterDb.initConnection()
cond = {"clientid": clientId}
dbData = masterDb.fetchData("regusers", ["password"], cond)
password = dbData[0][0]
adminDb = DatabaseAgent(clientId, clientId, conf.host, password, 5432)
adminDb.initConnection()
try:
responseData = adminDb.fetchData("projects", ["projectid"])
self.log.logEvent("projectManage", 0,
"projectId listed successfully", clientId,
sessionMange.session[sessionkey]["userid"])
response = {
"Header": {
"status": "success",
"module": "projectManage"
},
"Body": {
"message": "project idlist",
"data": responseData
},
"Signature": {
"signature": "",
"Key": ""
}
}
return response
except Exception as expc:
# self.syslog.eventHandle("projectmanagement","exception","exception on projectManage module",str(expc))
self.log.logEvent("projectManage", 3, str(expc), clientId,
sessionMange.session[sessionkey]["userid"])
# pro = projectManage()
# pro.listProjects("kec119","karthi007")
def listClientUser(self, clientId, sessionkey):
masterDb = DatabaseAgent(conf.mdbName, conf.muserName, conf.host,
conf.mdbPassword, conf.port)
masterDb.initConnection()
cond = {"clientid": clientId}
dbData = masterDb.fetchData("regusers", ["password"], cond)
password = dbData[0][0]
print(".................", dbData)
adminDb = DatabaseAgent(clientId, clientId, conf.host, password, 5432)
adminDb.initConnection()
datalis = [
"fullname", "employeeid", "designation", "userrole", 'archive'
]
self.log.logEvent("Admin", 0, "Client user listed successfully",
clientId, sessionMange.session[sessionkey]["userid"])
try:
responseData = adminDb.fetchData("clientusers", datalis)
print("dbdata is................................", responseData)
response = {
"Header": {
"status": "success",
"module": "admin"
},
"Body": {
"message": "user list",
"data": responseData
},
"Signature": {
"signature": "",
"Key": ""
}
}
return response
except Exception as expc:
self.log.logEvent("Admin", 0, "occured exception is " + str(expc),
clientId,
sessionMange.session[sessionkey]["userid"])
def shiftAssingn(self,clientId,msgDict,sessionkey):
masterDb = DatabaseAgent(conf.mdbName,conf.muserName,conf.host,conf.mdbPassword,conf.port)
masterDb.initConnection()
cond = {"clientid":clientId}
dbData = masterDb.fetchData("regusers",["password"],cond)
password = dbData[0][0]
adminDb = DatabaseAgent(clientId, clientId, conf.host,password, 5432)
adminDb.initConnection()
changDict = {"shiftid":msgDict["shiftId"]}
condition = {}
for key in msgDict:
condition[key.lower()] = (msgDict[key])
self.log.logEvent("shiftManage",2,"shift assigned successfully",clientId,sessionMange.session[sessionkey]["userid"])
reval = False
try:
reval = adminDb.editData("labourer",changDict,condition)
except Exception as expc:
# self.syslog.eventHandle("shiftmanage","exception","exception on shiftManage module",str(expc))
print("oocured exception is",expc)
if reval:
self.log.logEvent("shiftManage",2,"shift can't assigned ",clientId,sessionMange.session[sessionkey]["userid"])
return "shift assingend successfully" #admin.labouerList()
def classAdding(self,clientId,msgDict,sessionkey):
masterDb = DatabaseAgent(conf.mdbName,conf.muserName,conf.host,conf.mdbPassword,conf.port)
masterDb.initConnection()
cond = {"clientid":clientId}
dbData = masterDb.fetchData("regusers",["password"],cond)
password = dbData[0][0]
adminDb = DatabaseAgent(clientId, clientId, conf.host,password, 5432)
adminDb.initConnection()
keyList =[]
valList = []
for key in msgDict:
keyList.append(key.lower())
valList.append(msgDict[key])
try:
if adminDb.pushData("labourerclass",keyList,valList):
self.log.logEvent("Admin",2,msgDict["labourerClass"]+" class added successfully",clientId,sessionMange.session[sessionkey]["userid"])
response = {"Header":{"status":"success","module":"labourerClass"},"Body":{"message":"class added successfully","data":""},"Signature":{"signature":"","Key":""}}
return response
else:
response = {"Header":{"status":"fail","module":"labourerClass"},"Body":{"message":"class can't added","data":""},"Signature":{"signature":"","Key":""}}
return response
except Exception as expc:
# self.syslog.eventHandle("labourerclassManage","exception","exception on labourerclassManage module",str(expc))
self.log.logEvent("labourerclassManage",2,"occured expection is"+str(expc),clientId,sessionMange.session[sessionkey]["userid"])
def fincheck(self):
recdict = bytes(self.storage[0]).decode("utf-8")
print("nomore clients here/////////", recdict)
dataDict = json.loads(recdict)
bigstr = ""
nameLs = []
valueLs = []
for key in dataDict:
if key == "FinSig":
nameLs.append(key)
valueLs.append(dataDict[key])
continue
else:
bigstr += dataDict[key]
nameLs.append(key)
valueLs.append(dataDict[key])
print("nomore clients here/////////", bigstr)
sign = hashlib.md5(bigstr.encode("utf-8")).hexdigest()
print("sign value is", sign)
if dataDict["FinSig"] == sign:
masterDb = DatabaseAgent(conf.mdbName, conf.muserName, conf.host,
conf.mdbPassword, conf.port)
masterDb.initConnection()
if not masterDb.fetchSyslogg():
entry = sign + "GEN000000X"
else:
dbEntryId = masterDb.fetchSyslogg()
# decoEntryId = bytes(dbEntryId[0][0]).decode("utf-8")
# print("entryid",str(decoEntryId))
entry = sign + dbEntryId[0][0]
hash = hashlib.md5(entry.encode()).hexdigest()
firstChar = hash[0]
while firstChar != "0":
hash = hashlib.md5(hash.encode()).hexdigest()
print("Entry ID hash: Current hash = ", hash)
firstChar = hash[0]
print("true")
nameLs.append("entryid")
valueLs.append(hash[:10])
masterDb.pushData("syslogg", nameLs, valueLs)
else:
print("fing signature is wrong")
