class DirectQuery: """ For piping queries to MSH and building pools of stems from related concepts. """ def __init__(self, identifier): """ :param identifier: (str) search term Other attributes are all defaults by design. """ #authorize self.AuthClient = Authentication() self.AuthClient.gettgt() #set attributes self.identifier = identifier self.version = "current" self.source = "MSH" self.returntype = "concept" #send the query and return dataframe self.get_query_result() self.df = self.parse_query_result() def get_query_result(self): """ Search by human-readable string. :return: concepts """ uri = "https://uts-ws.nlm.nih.gov" content_endpoint = "/rest/search/{0}?string={1}&sabs={2}&returnIdType={3}".format( self.version, self.identifier, self.source, self.returntype) self.query = {'ticket':self.AuthClient.getst()} r = requests.get(uri+content_endpoint, params=self.query) items = json.loads(r.text) self.jsonData = items["result"] def parse_query_result(self): """ Extract name and unique id from results. :return: pandas dataframe """ results = self.jsonData['results'] df = pd.DataFrame(results) df.drop(['rootSource', 'uri'], axis=1, inplace=True) return df
def __init__(self, clientId, data, verifykey, apiEndPoint): self.message = data self.sessionkey = verifykey self.apiEndPoint = apiEndPoint self.splitUrl = apiEndPoint.split('/') self.auth = Authentication() self.master = Master() self.admin = Admin() self.role = roleManage() self.attendance = attendanceManage() self.project = projectManage() self.labourer = labbourerManage() self.labclass = labourerClass() self.shift = shiftManage() self.log = Logger() self.paymentDesk = paymentDesk() self.clientId = clientId
def get(self): activity = Activity() from Authentication import Authentication authentication = Authentication(users) print(activity) return ({ "activity": str(activity), "user": str(authentication), "location": "home" })
def get_umls_ticket2(tgt=tgt, AuthClient=AuthClient, apikey=umls_api): """ Get a single use ticket for the UMLS REST services. It is supposed that an Author Client and a Ticket Granting Service have already been set-up in case the apikey = None. If an api-key is given, create the above needed instances and generate a new ticket. Input: - apikey: str, UMLS REST services api-key. Default is None and the already establised service is used Output: - string of the generated ticket """ # Get ticket from the already establised service if not (tgt) and not (AuthClient): AuthClient = Authentication(umls_api) tgt = AuthClient.gettgt() return AuthClient.getst(tgt)
def handle(self): """ Handle requests from the clients. :return: """ global auth_dict, nonce_dict, crypto_service, password_hash_dict, user_addr_dict, chatting_service msg = self.request[0] sock = self.request[1] # get auth instance for client if self.client_address not in auth_dict: try: _, msg_parts = PacketOrganiser.process_packet(msg) except: return if msg_parts[0] != c.GREETING: return # new client, create an auth entry in the auth dictionary auth_dict[self.client_address] = Authentication( self.client_address, crypto_service, password_hash_dict) else: auth = auth_dict[self.client_address] if not PacketOrganiser.isValidTimeStampSeconds( auth.timestamp, c.KEEP_ALIVE_TIME): auth_dict.pop(self.client_address) cur_auth = auth_dict[self.client_address] assert isinstance(cur_auth, Authentication) rep = None if not cur_auth.is_auth(): rep = cur_auth.process_request(msg, user_addr_dict) else: # get decrypted msg dec_msg = crypto_service.sym_decrypt(cur_auth.dh_key, msg) n, msg_ps = PacketOrganiser.process_packet(dec_msg) auth_dict[ self. client_address].timestamp = PacketOrganiser.get_new_timestamp( ) # update timestamp rep = chatting_service.get_response(self.client_address, msg_ps) if rep is not None: rep = PacketOrganiser.prepare_packet(rep, n) rep = crypto_service.sym_encrypt(cur_auth.dh_key, rep) try: if rep is not None: sys.stdout.flush() sock.sendto(rep, self.client_address) elif cur_auth.is_auth(): cur_auth.loginfailures += 1 except socket.error: print(c.FAIL_MSG_FWD) return
def __init__(self, user, key): self.auth = Authentication(user, key) try: self.auth.doLogin() except RackSpaceAuthenticationFailedException: print "Invalid credentials was provided!" self.auth = None except RackSpaceException: print "Error during auth procedure" # sys.exit(1) self.auth = None self.updateAuthToken(self.auth.getAuthToken())
def find_snomedct_server(term): apikey = "ca310f05-53e6-4984-82fd-8691dc30174e" AuthClient = Authentication(apikey) version = "2017AB" tgt = AuthClient.gettgt() query = {'ticket': AuthClient.getst(tgt), 'targetSource': 'SNOMEDCT_US'} base_uri = "https://uts-ws.nlm.nih.gov/rest" search_uri = "/search/current?string=" content_uri = "/content/current/CUI/" source = "&sabs=SNOMEDCT_US" search_type = '&searchType=words' path = base_uri + search_uri + term + search_type + source r = requests.get(path, params=query) code, name, semantic = "", "", "" try: items = json.loads(r.text) pprint(items['result']['results']) code, name = select_code(items['result']['results'], term) if code != "": path2 = base_uri + content_uri + code tgt2 = AuthClient.gettgt() query2 = { 'ticket': AuthClient.getst(tgt2), 'targetSource': 'SNOMEDCT_US' } r2 = requests.get(path2, params=query2) try: items2 = json.loads(r2.text) semantic = items2['result']['semanticTypes'][0]['name'] except json.decoder.JSONDecodeError: semantic = "UNKNOWN" except json.decoder.JSONDecodeError: code, name = "", "" return code, name, semantic
def main(self): auth.auth(self.b, self.selector) cons = Conss() # if cons.toBeMessaged(): # print("the file is empty so we are going to get new connecitons") # cons.getConnection(self.b,self.selector,self.soup) message_file = open(credentials.MESSAGE_FILE_PATH, "r") message = message_file.read() # lastPresent = False # last = open(credentials.LAST_CONNECTION_SENT_MESSAGE_FILE_PATH,"r") # if last == "": # lastPresent = True # print=(last) for connection in cons.loadConnections(): # print(f"{connection.name} {connection.profile}") # if not lastPresent: # if f"{connection.name} {connection.profile}" == last: # lastPresent = True # else: # continue # print("sending connection message") connection.sendMessage(self.b, self.selector, message, webdriver) message_file.close()
def on_status(self, status): registration_ids = Authentication.firebase_registration_ids() message_title = "Support Alert" message_body = status.text message_data = { "link": "https://twitter.com/statuses/" + str(status.id), "alternative_link": "http://twitter.com/none/status/" + str(status.id) } self.push_service.notify_multiple_devices( registration_ids=registration_ids, message_title=message_title, message_body=message_body, data_message=message_data)
class DatabaseService: def __init__(self): self.authentication = Authentication() def login(self, username, password): result = Authentication().login(username, password) return result def register(self, data): result = self.authentication.register(data) return result def check_token(self, data): result = self.authentication.check_token(data) return result def getAll(self): return self.authentication.getAll() def getByCategory(self, category): return self.authentication.getByCategory(category) def search(self, inp): return self.authentication.search(inp)
def __init__(self, identifier): """ :param identifier: (str) search term Other attributes are all defaults by design. """ #authorize self.AuthClient = Authentication() self.AuthClient.gettgt() #set attributes self.identifier = identifier self.version = "current" self.source = "MSH" self.returntype = "concept" #send the query and return dataframe self.get_query_result() self.df = self.parse_query_result()
class TwitterStreamListener(tweepy.StreamListener): push_service = FCMNotification(api_key=Authentication.firebase_auth_key()) def on_status(self, status): registration_ids = Authentication.firebase_registration_ids() message_title = "Support Alert" message_body = status.text message_data = { "link": "https://twitter.com/statuses/" + str(status.id), "alternative_link": "http://twitter.com/none/status/" + str(status.id) } self.push_service.notify_multiple_devices( registration_ids=registration_ids, message_title=message_title, message_body=message_body, data_message=message_data) def on_error(self, status_code): if status_code == 420: # returning False in on_data disconnects the stream return False
def authenticate(): authen = Authentication.validate_access() if not authen: abort(401)
import telebot from Authentication import Authentication as Auth from DataBase import EvandExcelParser as EEP import pandas as pd TOKEN = '691564985:AAH-B1geClWEv-cUsosVs_PldlLfQSuvd00' bot = telebot.TeleBot(TOKEN) auth = Auth(path_file='users_telegram/') auth.set_state_list(['start', 'get_identication', 'complete']) eep = EEP(file_path='list.xlsx') users_row = dict() def identication_parser(message): if auth.get_state(message) == 'start': return 1 else: return 0 def entername_stage(message): if auth.get_state(message) == 'get_identication': return 1 else: return 0 @bot.message_handler(commands=['start']) def start_command_response(message): print(message.chat)
def __init__(self): self.log = Logger() self .authen = Authentication()
def cli_authenticate(self): #username = args.username #password = args.password self.AuthClient = Authentication()
class ModuleLauncher: def __init__(self, clientId, data, verifykey, apiEndPoint): self.message = data self.sessionkey = verifykey self.apiEndPoint = apiEndPoint self.splitUrl = apiEndPoint.split('/') self.auth = Authentication() self.master = Master() self.admin = Admin() self.role = roleManage() self.attendance = attendanceManage() self.project = projectManage() self.labourer = labbourerManage() self.labclass = labourerClass() self.shift = shiftManage() self.log = Logger() self.paymentDesk = paymentDesk() self.clientId = clientId def handleRequest(self): if self.splitUrl[0] == "master": return self.handleMaster() elif self.apiEndPoint == "/register": return self.master.adminRegister(self.message, self.sessionkey) elif self.apiEndPoint == "/companyprofile": return self.admin.companyProfile(self.clientId, self.sessionkey) elif self.apiEndPoint == "/userprofile": return self.admin.userProfile(self.clientId, self.message, self.sessionkey) else: return self.handleClient(self.splitUrl[0]) def handleClient(self, clientId): if self.splitUrl[1] == "login": return self.admin.login(self.clientId, self.message, self.sessionkey) elif self.splitUrl[1] == "user": return self.handleClientUser() elif self.splitUrl[1] == "projects": return self.handleProjects() elif self.splitUrl[1] == "paymentDesk": return self.handlePaymentDesk() elif self.splitUrl[1] == "userrole": return self.roleManage() elif self.splitUrl[1] == "labourer": return self.handleLabourer() elif self.splitUrl[1] == "attendance": if self.splitUrl[2] == "list": return self.attendance.getAttendace(self.clientId, self.sessionkey) elif self.splitUrl[1] == "logout": return self.auth.logout(self.message, self.sessionkey) elif self.splitUrl[1] == "payments": pass else: self.log.logEvent("ModuleLauncher", 3, "wrong url acess") return "url does not defined" def handleMaster(self): if self.splitUrl[1] == "login": return self.master.login(self.message, self.sessionkey) elif self.splitUrl[1] == "register": # digest = self.auth.signUp(self.message["password"]) # self.message["password"] = digest["hashPassword"] # self.message["salt"] = digest["salt"] # print("message",self.message) # return self.master.createMaster(self.message) # self.log.logEvent("ModuleLauncher",3,"Master registerd") return self.master.createMaster(self.message, self.sessionkey) #return "sucess" elif self.splitUrl[1] == "user": return self.handleMasterUser() elif self.splitUrl[1] == "app": if self.splitUrl[2] == "logs": return self.master.fetchAppLogs(self.message, self.sessionkey) elif self.splitUrl[1] == "clients": return self.handleMasterclients() elif self.splitUrl[1] == "logout": return self.auth.logout(self.message, self.sessionkey) else: print("master can't have this endpoint") self.log.logEvent("ModuleLauncher", 3, "master can't have this endpoint") return "master can't have this endpoint" def handleMasterUser(self): if self.splitUrl[2] == "add": return self.master.addUser(self.message, self.sessionkey) elif self.splitUrl[2] == "delete": return self.master.deleteUser(self.message, self.sessionkey) elif self.splitUrl[2] == "list": return self.master.listUser(self.sessionkey) elif self.splitUrl[2] == "editlist": return self.master.mastereditList(self.message, self.sessionkey) elif self.splitUrl[2] == "save": return self.master.editUser(self.message, self.sessionkey) elif self.splitUrl[2] == "archive": return self.master.archiveUser(self.message, self.sessionkey) elif self.splitUrl[2] == "unarchive": return self.master.unArchiveUser(self.message, self.sessionkey) else: self.log.logEvent("ModuleLauncher", 3, "master_user can't have this endpoint") return "wrong url access1" def handleMasterclients(self): if self.splitUrl[2] == "list": return self.master.getRegUserDetails(self.sessionkey) elif self.splitUrl[2] == "editlist": return self.master.clienteditList(self.message) elif self.splitUrl[2] == 'delete': return self.master.deleteClient(self.message, self.sessionkey) elif self.splitUrl[2] == "archive": return self.master.archiveClient(self.message, self.sessionkey) elif self.splitUrl[2] == "save": return self.master.editClient(self.message, self.sessionkey) elif self.splitUrl[2] == "approve": return self.master.clientApprove(self.message, self.sessionkey) elif self.splitUrl[2] == "reject": self.master.rejectClients(self.message, self.sessionkey) else: self.log.logEvent("ModuleLauncher", 3, "master_client can't have this endpoint") return "url access error" def handleClientUser(self): if self.splitUrl[2] == "add": return self.admin.addUser(self.clientId, self.message, self.sessionkey) elif self.splitUrl[2] == "delete": return self.admin.deleteUser(self.clientId, self.message, self.sessionkey) elif self.splitUrl[2] == "save": return self.admin.editUser(self.clientId, self.message, self.sessionkey) elif self.splitUrl[2] == "archive": return self.admin.archiveUser(self.clientId, self.message, self.sessionkey) elif self.splitUrl[2] == "unarchive": return self.admin.unArchiveUser(self.clientId, self.message, self.sessionkey) elif self.splitUrl[2] == "list": return self.admin.listClientUser(self.clientId, self.sessionkey) elif self.splitUrl[2] == "roles": return self.admin.roleList(self.clientId, self.sessionkey) elif self.splitUrl[2] == "editlist": return self.admin.editList(self.clientId, self.message, self.sessionkey) else: self.log.logEvent("ModuleLauncher", 3, "client_user can't have this endpoint") return "wrong url access2" def handleProjects(self): if self.splitUrl[2] == "list": return self.project.listProjects(self.clientId, self.sessionkey) elif self.splitUrl[2] == "add": return self.project.projectsAdding(self.clientId, self.message, self.sessionkey) elif self.splitUrl[2] == "siteadd": return self.project.addSites(self.clientId, self.message, self.sessionkey) elif self.splitUrl[2] == "editList": return self.project.editList(self.clientId, self.message, self.sessionkey) elif self.splitUrl[2] == "sitedelete": return self.project.deletSites(self.clientId, self.message, self.sessionkey) elif self.splitUrl[2] == "idList": return self.project.projectIdList(self.clientId, self.sessionkey) else: self.log.logEvent("ModuleLauncher", 3, "client_user can't have this endpoint") return "wrong url access2" def handleLabourer(self): if self.splitUrl[2] == "info": return self.labourer.labourerInfo(self.clientId, self.message, self.sessionkey) elif self.splitUrl[2] == "list": return self.labourer.labouerList(self.clientId, self.sessionkey) elif self.splitUrl[2] == "personalInfo": return self.labourer.personalInfo(self.clientId, self.message, self.sessionkey) elif self.splitUrl[2] == "employeeInfo": return self.labourer.employeeInfo(self.clientId, self.message, self.sessionkey) elif self.splitUrl[2] == "identityInfo": return self.labourer.identityInfo(self.clientId, self.message, self.sessionkey) elif self.splitUrl[2] == "bankInfo": return self.labourer.bankInfo(self.clientId, self.message, self.sessionkey) elif self.splitUrl[2] == "save": return self.labourer.labourerReg(self.clientId, self.message, self.sessionkey) elif self.splitUrl[2] == "update": return self.labourer.editLabourer(self.clientId, self.message, self.sessionkey) elif self.splitUrl[2] == "delete": return self.labourer.deleteLabourer(self.clientId, self.message, self.sessionkey) elif self.splitUrl[2] == "attendance": return self.labourer.getAttendacePers(self.clientId, self.message, self.sessionkey) elif self.splitUrl[2] == "class": return self.classManage() elif self.splitUrl[2] == "addlist": return self.labourer.labbourerAddlist(self.clientId, self.sessionkey) elif self.splitUrl[2] == "shift": return self.shiftManage() else: return "wrong url access" def shiftManage(self): if self.splitUrl[3] == "add": return self.shift.shiftCreation(self.clientId, self.message, self.sessionkey) elif self.splitUrl[3] == "list": return self.shift.shiftList(self.clientId, self.sessionkey) elif self.splitUrl[3] == "delete": return self.shift.shiftDeleted(self.clientId, self.message, self.sessionkey) else: return "wrong url acess" def classManage(self): if self.splitUrl[3] == "list": return self.labclass.classList(self.clientId, self.sessionkey) elif self.splitUrl[3] == "add": return self.labclass.classAdding(self.clientId, self.message, self.sessionkey) elif self.splitUrl[3] == "delete": return self.labclass.classDelete(self.clientId, self.message, self.sessionkey) else: return "wrong url acess" def roleManage(self): if self.splitUrl[2] == "add": return self.role.createRoles(self.clientId, self.message, self.sessionkey) elif self.splitUrl[2] == "list": return self.role.listRoles(self.clientId, self.sessionkey) elif self.splitUrl[2] == "update": return self.role.editRoles(self.clientId, self.message, self.sessionkey) else: return "wrong url acess" def handlePaymentDesk(self): if self.splitUrl[2] == "apply": return self.paymentDesk.advanceApply(self.clientId, self.message, self.sessionkey) elif self.splitUrl[2] == "applyList": return self.paymentDesk.requstList(self.clientId, self.sessionkey) elif self.splitUrl[2] == "payList": return self.paymentDesk.advancePayList(self.clientId, self.sessionkey) elif self.splitUrl[2] == "approveCodeList": return self.paymentDesk.approvecodeList(self.clientId, self.message, self.sessionkey) elif self.splitUrl[2] == "payment": return self.paymentDesk.payProcess(self.clientId, self.message, self.sessionkey) elif self.splitUrl[2] == "status": return self.paymentDesk.advanceRespo(self.clientId, self.message, self.sessionkey) elif self.splitUrl[2] == "approve": return self.paymentDesk.requstApprove(self.clientId, self.message, self.sessionkey) elif self.splitUrl[2] == "reject": return self.paymentDesk.requstReject(self.clientId, self.message, self.sessionkey) else: return "wrong url acess"
Utility functions. """ import time import logging import requests import json from config import settings from Authentication import Authentication # API-kEY FOR UMLS REST TICKET SERVICES umls_api = settings['apis']['umls'] # UMLS REST SERVICES INITIALIZATION OF CLIENT AND TICKET # GRANTING SERVICE TO BE USED IN ALL CASES AuthClient = Authentication(umls_api) tgt = AuthClient.gettgt() logging.getLogger("requests").setLevel(logging.WARNING) logging.getLogger("urllib3").setLevel(logging.WARNING) def get_umls_ticket2(tgt=tgt, AuthClient=AuthClient, apikey=umls_api): """ Get a single use ticket for the UMLS REST services. It is supposed that an Author Client and a Ticket Granting Service have already been set-up in case the apikey = None. If an api-key is given, create the above needed instances and generate a new ticket. Input: - apikey: str,
def Api(self): self.judger = Authentication()
import socket from Authentication import Authentication def get_ip(): s = socket.socket(socket.AF_INET, socket.SOCK_DGRAM) try: # doesn't even have to be reachable s.connect(('10.255.255.255', 1)) IP = s.getsockname()[0] except: IP = '127.0.0.1' finally: s.close() return IP auth = Authentication() client_ip = get_ip() username = input("User name: ") if auth.authenticate_user(username, client_ip): print("user authenticated: true") else: print("user authenticated: false")
# auth.publicVerification() # pubkey = b'\x1aA)\x16\xf3\x03\x0f!\xdc/#:\xd7n\xb2\xf1\x03\x8f\xd2\xfa\x80.\x12\xf8HG\x85\xe3\x14\x0b\x159' # # msg = "karthiban" # cond = {"userid":"1551"} # # data = auth.encrypt(msg,pubkey,cond) # # print("karthihack",data) # encmsg = b'\x91\x12n\xd9\xdd\x19\x1d\xcd\xe6\x87\xcd\x037\x01\xa4\xbc\xbb\xf6\xda\xb9\xfaI\xa0]\xacA\xdb\xeb\xcc\xd3\x8a\x7f\xdf\xe3\xeb\xec\xad\xb2\xd9\x1f\x8d\xcfm;\x8b\x87\xfc\xc3W' # realtext = auth.decrypt(encmsg,pubkey,cond) # print("text",realtext) #signup test auth = Authentication() #some = auth.signUp("karthiban") auth.testing() # print("returnvalue",some["salt"]) # print("msge=",some["hashPassword"]) # #login # msg = {} # msg["username"] = "******" # msg["password"] = "******" # tt = auth.login(msg) # print("fg ",tt) # print("session" ,console.sessions[sessid][0][3])
writer = csv.writer(f, delimiter=";") writer.writerow( [text, tags, user, time, location, coordinates]) # Increment counter MyStreamListener.counter += 1 def on_error(self, status_code): print(status_code) return False if __name__ == "__main__": FILE_NAME = "#CoronaHoax.csv" api = Authentication(isApp=False).get_api() auth = api.auth myStreamListener = MyStreamListener(FILE_NAME) myStream = tweepy.Stream(auth=auth, listener=myStreamListener) try: print('Start streaming...') myStream.filter(languages=['en'], track=[ "#CoronaHoax", "#CovidHoax", "#coronahoax", "#covidhoax", "plandemic", "Plandemic", "#scamdemic", "#Scamdemic", "#SCAMDEMIC" ]) except KeyboardInterrupt: print("Stopped.")
def __init__(self): self.auth = Authentication() self.log = Logger() self.rejx = dataVerify()
class Communication: def __init__(self): self.auth = Authentication() self.log = Logger() self.rejx = dataVerify() # self.modulauncher = ModuleLauncher() # self.launcher = ModuleLauncher() # def seralize(self,dicto): # #self.deseralize(data_json) # obj = json.dumps(dicto,default=getDict) # return obj def deserialize(self, jsonData): try: deserialized = json.loads(jsonData) print(deserialized) return deserialized except Exception as expc: self.log.logEvent("communication deserialize",2,"exception ocureed"+str(expc)) def verifyStructure(self, msgDict): try: containsHeader = False containsBody = False containsExtraField = False containsSignature = False for key in msgDict: if key == "Header": containsHeader = True elif key == "Body": containsBody = True elif key == "Signature": containsSignature = True else: containsExtraField = True break return containsHeader and containsSignature and containsBody and not containsExtraField except Exception as expc: self.log.logEvent("communication verify structure function",2,"exception ocureed"+str(expc)) def createMessage(self, dictData, message): try: message.header = dictData["Header"] message.body = dictData["Body"] message.Signature = dictData["Signature"] except Exception as expc: self.log.logEvent("communication at create message function",2,"exception ocureed"+str(expc)) def sanitizeBody(self,msgBody): try: success = False for key in msgBody: if self.sanitizeString(key): if type(msgBody[key]) is dict: if not self.sanitizeBody(msgBody[key]): return False else: success = True self.sanitizeBody(msgBody[key]) else: if self.sanitizeString(msgBody[key]): success = True continue else: success = False else: return False return success except Exception as expc: self.log.logEvent("communication at sanatizeBody function",2,"exception ocureed"+str(expc)) def sanitizeHeader(self,msgheader): try: success = True for msg in msgheader: if self.sanitizeString(msg): if self.sanitizeString(msgheader[msg]): continue else: success = False else: success = False return success except Exception as expc: self.log.logEvent("communication at sanitizeHeader function",2,"exception ocureed"+str(expc)) def sanitizeString(self, stringData): try: text = str(stringData) print("data is" + text) ignore_words = [';','"','$','&&','../','*','<','>','%3C','%3E','\'','--','1,2','\x00','`','(',')','file://','input://'] for ch in ignore_words: if ch in text: print("1false") return False return True except Exception as expc: self.log.logEvent("communication at sanitizeString function",2,"exception ocureed"+str(expc)) #######################################################################master handle#######################################################################33 def receiveRequest(self,data,clientid,apiEndPoint): # try: print("JSON : ",data) msg = Message() signString = str(data).split("Body")[1] plainMsg = ((signString.split("Signature")[0])[:-2])[2:] dictData = self.deserialize(data) if self.verifyStructure(dictData): self.createMessage(dictData, msg) print("MESSAGE HEADER: ") for key in msg.Signature: print("keys ", key) if key == "signature": print(" encrypetedkey will be there") elif key == "Key": print("verfykey will be there") else: self.log.logEvent("Communication",3,"signatrue part is missing") print("signature missing there") return "signature missing there" verifyKey = msg.Signature["Key"] signature = msg.Signature["signature"] contStr = "" # print("signString..........................",plainMsg) # sigtest = self.auth.signatureVerify(verifyKey, signature,plainMsg) # print("Signature Verified::::::::::::::::::::::::::::::::::::::", sigtest) if self.auth.signatureVerify(verifyKey, signature,plainMsg): if self.rejx.verifyData(msg.body): if clientid == "signup" : modLauncher = ModuleLauncher(clientid, msg.body,verifyKey,'/register') return modLauncher.handleRequest() elif clientid == "masterregister": modLauncher = ModuleLauncher(clientid,msg.body,verifyKey, apiEndPoint) return modLauncher.handleRequest() elif clientid == "master": modLauncher = ModuleLauncher(clientid,msg.body,verifyKey, apiEndPoint) # return modLauncher.handleRequest() resDict = modLauncher.handleRequest() body = resDict["Body"] print("body part is....",body) jsnfyBody = json.dumps(body) print("jsnfyBody) = ",jsnfyBody) if resDict["Header"]["status"] == "success": signkey1 = sessionMange.session[verifyKey]["signkey"] verifykey1 = sessionMange.session[verifyKey]["verifykey"] print("verifykey type",type(verifykey1)) verify_key_hex =verifykey1.encode(encoder=nacl.encoding.HexEncoder) print("signature private key type",type(signkey1)) print("type(jsnfyBody) = ", type(jsnfyBody)) sessionSign = signkey1.sign(jsnfyBody.encode("utf-8")) print("sessionkey type",type(sessionSign)) print("sessionkey ............on backend",sessionSign) sHexSignature = binascii.hexlify(bytes(sessionSign)) resDict["Signature"]["signature"] = (sHexSignature) resDict["Signature"]["Key"] = (verify_key_hex) print("siggened signature message................................",resDict) return resDict elif apiEndPoint == "/login": # modLauncher = ModuleLauncher(clientid,msg.body,verifyKey, apiEndPoint) # return modLauncher.handleRequest() try: modLauncher = ModuleLauncher(clientid,msg.body,verifyKey, apiEndPoint) resDict = modLauncher.handleRequest() body = resDict["Body"] print("body part is....",body) jsnfyBody = json.dumps(body) print("jsnfyBody) = ",jsnfyBody) if resDict["Header"]["status"] == "success": signkey1 = sessionMange.session[verifyKey]["signkey"] verifykey1 = sessionMange.session[verifyKey]["verifykey"] print("verifykey type",type(verifykey1)) verify_key_hex =verifykey1.encode(encoder=nacl.encoding.HexEncoder) print("signature private key type",type(signkey1)) print("type(jsnfyBody) = ", type(jsnfyBody)) sessionSign = signkey1.sign(jsnfyBody.encode("utf-8")) print("sessionkey type",type(sessionSign)) print("sessionkey ............",sessionSign) sHexSignature = binascii.hexlify(bytes(sessionSign)) resDict["Signature"]["signature"] = (sHexSignature) resDict["Signature"]["Key"] = (verify_key_hex) return resDict except Exception as expc: print("expection",expc) response = {"Header":{"status":"fail","module":"communication"},"Body":{"message":"wrong username or password","data":""},"Signature":{"signature":"","Key":""}} return response elif apiEndPoint == "/logout": modLauncher = ModuleLauncher(clientid,msg.body,verifyKey, apiEndPoint) return modLauncher.handleRequest() # resDict = modLauncher.handleRequest() # body = resDict["Body"] # print("body part is....",body) # jsnfyBody = str(jsonify(body)) # signkey1 = sessionMange.session[verifyKey]["signkey"] # verifykey1 = sessionMange.session[verifyKey]["verifykey"] # verify_key_hex =verifykey1.encode(encoder=nacl.encoding.HexEncoder) # print("signature private key type",type(signkey1)) # print("type(jsnfyBody) = ", type(jsnfyBody)) # sessionSign = signkey1.sign(jsnfyBody.encode("utf-8")) # print("sessionkey type",type(sessionSign)) # sHexSignature = binascii.hexlify(bytes(sessionSign)) # resDict["Signature"]["signature"] = (sHexSignature) # resDict["Signature"]["Key"] = (verify_key_hex) # return resDict elif self.auth.uRolePermissionCheck(clientid,apiEndPoint,verifyKey) : # try: modLauncher = ModuleLauncher(clientid,msg.body,verifyKey, apiEndPoint) resDict = modLauncher.handleRequest() body = resDict["Body"] print("body part is....",body) jsnfyBody = json.dumps(body) print("jsnfyBody) = ",jsnfyBody) if resDict["Header"]["status"] == "success": signkey1 = sessionMange.session[verifyKey]["signkey"] verifykey1 = sessionMange.session[verifyKey]["verifykey"] print("verifykey type",type(verifykey1)) verify_key_hex =verifykey1.encode(encoder=nacl.encoding.HexEncoder) print("signature private key type",type(signkey1)) print("type(jsnfyBody) = ", type(jsnfyBody)) sessionSign = signkey1.sign(jsnfyBody.encode("utf-8")) print("sessionkey type",type(sessionSign)) print("sessionkey ............",sessionSign) sHexSignature = binascii.hexlify(bytes(sessionSign)) resDict["Signature"]["signature"] = (sHexSignature) resDict["Signature"]["Key"] = (verify_key_hex) return resDict # except Exception as expc: # print("expection",expc) # self.log.logEvent("communication",2,"role checking function ") else: print(">>............................wrong datastructure") return " wrong datastructure at communication" else: self.log.logEvent("Communication",3,"signature is wrong") return "error occured" elif self.sanitizeBody(msg.body) and self.sanitizeHeader(msg.header): print("Message body verified") else: self.log.logEvent("Communication",3,"invalied requst formate") print("Invalid body structure format ") return "Invalid body structure format "
def login(self, username, password): result = Authentication().login(username, password) return result
def __init__(self): self.authentication = Authentication()
class RackSpaceClient: VALID_HTTP_METHODS = ("GET", "POST", "DELETE", "PUT") # Authentication object auth = None # Default headers headers = {"Content-Type": "application/json", "Accept": "application/json"} connection = None def __init__(self, user, key): self.auth = Authentication(user, key) try: self.auth.doLogin() except RackSpaceAuthenticationFailedException: print "Invalid credentials was provided!" self.auth = None except RackSpaceException: print "Error during auth procedure" # sys.exit(1) self.auth = None self.updateAuthToken(self.auth.getAuthToken()) # print self.headers def updateAuthToken(self, token): self.headers.update({"X-Auth-Token": token}) def makeConnection(self, hostname, port): self.closeConnection() self.connection = HTTPSConnection(hostname, port) def closeConnection(self): if self.connection is not None: self.connection.close() def SendRequest(self, rType, method, data, params): # Send API request if rType not in self.VALID_HTTP_METHODS: # Invalid request method raise RackSpaceException() uri = urlparse.urlparse(self.auth.getServerManagementURL()) headers = self.headers.copy() if isinstance(params, dict): headers.update(params) def make_request(): self.makeConnection(uri.hostname, uri.port) self.connection.request(rType, self.auth.getServerManagementURL() + method, data, headers) resp = self.connection.getresponse() return resp response = make_request() # 401 == unauthorized if response.status == 401: try: self.auth.doLogin() # retry request response = make_request() except RackSpaceException: self.closeConnection() raise # if response.status == 413: # raise RackSpaceOverLimitException() # if response.status == 400 or response.status == 500: # raise RackSpaceCloudServersFaultException() # if response.status == 503: # raise RackSpaceServiceUnavailableException() result = {"code": response.status, "body": response.read()} self.closeConnection() return result
def auth(callback: Callable, request: request, admin: bool = True, id_user: bool = False) -> tuple: authentication = Authentication(admin) if (authentication.is_authenticated(request)): return callback(authentication.get_id_user()) if id_user else callback() else: return Response(ResponseType.INVALID_CREDENTIALS).message()
import sys # My libraries from Authentication import Authentication from HarvestingTweets import BasicHarvestTweets from GatherTweets import GatherTweetsByWords, GatherTweetsByAccounts if __name__ == "__main__": data_path = "/home/user/TwitterData" auth = Authentication() if sys.argv[1] == "words": gtw = GatherTweetsByWords(BasicHarvestTweets(auth.auth, auth.api), ["startups", "machinelearning"]) gtw.gatherTweets(data_path, "words") elif sys.argv[1] == "accounts": gta = GatherTweetsByAccounts(BasicHarvestTweets(auth.auth, auth.api), ["Forbes", "businessinsider"]) gta.gatherTweets(data_path, "accounts") else: print(sys.argv[1] + " not implemented...")
class CLI: """ Command-line interface for querying single terms. More flexible, keeping around for potential future use/historical reasons. """ def __init__(self, argv=None): """ :param argv: for testing purposes only """ self.parser = argparse.ArgumentParser(description='process user given parameters') #parser.add_argument("-u", "--username", required = True, dest="username", help = "enter username") #parser.add_argument("-p", "--password", required = True, dest="password", help = "enter passowrd") self.parser.add_argument("-k", "--apikey", required = False, dest = "apikey", default = os.environ.get("APIKEY"), help = "enter api key from your UTS Profile") self.parser.add_argument("-v", "--version", required = False, dest="version", default = "current", help = "enter version example-2015AA") self.parser.add_argument("-i", "--identifier", required = True, dest="identifier", help = "enter identifier example-C0018787") self.parser.add_argument("-s", "--source", required = False, dest="source", default = 'MSH', help = "enter source name if known") self.parser.add_argument("-r", "--returntype", required = False, dest='returntype', default = "concept", help = "choose return type (‘aui’,‘concept’,‘code’,\ ‘sourceConcept’,‘sourceDescriptor’, ‘sourceUi’)") if argv is not None: self.args = self.parser.parse_args(argv) else: self.args = self.parser.parse_args() def cli_authenticate(self): #username = args.username #password = args.password self.AuthClient = Authentication() def construct_query(self): self.version = self.args.version self.identifier = self.args.identifier self.source = self.args.source self.returntype = self.args.returntype self.AuthClient.gettgt() def get_query_result(self): """ Search by human-readable string. :return: concepts """ self.construct_query() uri = "https://uts-ws.nlm.nih.gov" content_endpoint = "/rest/search/{0}?string={1}&sabs={2}&returnIdType={3}".format( self.version, self.identifier, self.source, self.returntype) self.query = {'ticket':self.AuthClient.getst()} r = requests.get(uri+content_endpoint, params=self.query) items = json.loads(r.text) self.jsonData = items["result"] #print(self.jsonData) ##uncomment the print statment if you want the raw json output, or you can just look at the documentation :=) #https://documentation.uts.nlm.nih.gov/rest/concept/index.html#sample-output #https://documentation.uts.nlm.nih.gov/rest/source-asserted-identifiers/index.html#sample-output #print (json.dumps(items, indent = 4)) def parse_query_result(self): """ Extract name and unique id from results. :return: pandas dataframe """ results = self.jsonData['results'] df = pd.DataFrame(results) df.drop(['rootSource', 'uri'], axis=1, inplace=True) return df
import Authentication.Authentication as aut import Manager.RepoManager as repom import json user = aut.login() class CommandsClass: def commands(catcher): n = 0 print("----- COMMANDS -----\n") with open("Commands\\Commands.json") as f: for command in json.load(f)["commands"]: print("({}): {}".format(n, command)) n += 1 def repos(catcher): print("----- REPOSITORIES -----") repom.list_repos(user) def create(name): repom.create_repo(user, name) def fpush(args): repom.fpush(user, args) def edit(args): repom.edit(user, args)
class Admin: def __init__(self): self.log = Logger() self.authen = Authentication() def addUser(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() digest = self.authen.signUp(msgDict["password"]) msgDict["password"] = digest["hashPassword"] msgDict["salt"] = digest["salt"] print("message", msgDict) # admin = Admin() nameLs = [] valueLs = [] for key, val in msgDict.items(): nameLs.append(key.lower()) valueLs.append(val) print(nameLs) print(valueLs) reval = False try: if not adminDb.fetchData("clientusers", ["username"], {"username": msgDict["userName"]}): if adminDb.pushData("clientusers", nameLs, valueLs): self.log.logEvent( "Admin", 1, msgDict["userName"] + " Client user registerd successfully", clientId, msgDict["userName"]) response = { "Header": { "status": "success", "module": "admin" }, "Body": { "message": "user added successfully", "data": "" }, "Signature": { "signature": "", "Key": "" } } return response else: self.log.logEvent( "Admin", 1, msgDict["userName"] + "Client user registerd failed and eception is occured") response = { "Header": { "status": "success", "module": "admin" }, "Body": { "message": "user can't added ", "data": "" }, "Signature": { "signature": "", "Key": "" } } return response else: self.log.logEvent( "Admin", 1, msgDict["userName"] + "Client user name alraedy exist", clientId, msgDict["userName"]) response = { "Header": { "status": "success", "module": "admin" }, "Body": { "message": "user name already exixt ", "data": "" }, "Signature": { "signature": "", "Key": "" } } return response except Exception as expc: self.log.logEvent("Admin", 0, "occured exception is " + str(expc)) # self.syslog.eventHandle("admin","exception","exception on admin module",str(expc)) def login(self, clientId, msgDict, sessionkey): masterDb = DatabaseAgent(conf.mdbName, conf.muserName, conf.host, conf.mdbPassword, conf.port) masterDb.initConnection() fileds = ["username", "password"] con = {"clientid": clientId} data = masterDb.fetchData("regusers", fileds, con) print("........................", data) datalis = [clientId, clientId, data[0][1], 5432] print("...datalis...........", datalis) adminDb = DatabaseAgent(clientId, clientId, conf.host, data[0][1], 5432) adminDb.initConnection() try: statusFlag = masterDb.fetchData("regusers", ["status"], {"clientid": clientId}) if statusFlag[0][0] == "approved": ##################################################################### filedLs = ["password", "salt", "employeeid", "userrole"] if self.authen.login(msgDict, "clientusers", filedLs, datalis, sessionkey): adminDb = DatabaseAgent(clientId, clientId, conf.host, data[0][1], 5432) adminDb.initConnection() userid = adminDb.fetchData( "clientusers", ["employeeid"], {"username": msgDict["userName"]}) archiveflag = adminDb.fetchData( "clientusers", ["archive"], {"username": msgDict["userName"]}) print("boolean value", archiveflag) if archiveflag: self.log.logEvent("Admin", 3, "user logined suceessfully", clientId, msgDict["userName"]) response = { "Header": { "status": "success", "module": "admin" }, "Body": { "message": "user login successfully", "data": userid }, "Signature": { "signature": "", "Key": "" } } return response else: self.log.logEvent( "Admin", 3, "your archived please connact to the admin", clientId, msgDict["userName"]) response = { "Header": { "status": "fail", "module": "admin" }, "Body": { "message": "your archived please connact to the admin", "data": "" }, "Signature": { "signature": "", "Key": "" } } return response else: self.log.logEvent("Admin", 3, "user logined error", clientId, msgDict["userName"]) response = { "Header": { "status": "fail", "module": "admin" }, "Body": { "message": "wrong username or password", "data": "" }, "Signature": { "signature": "", "Key": "" } } return response elif statusFlag[0][0] == "rejected": self.log.logEvent("Admin", 3, "comapny is rejected", clientId, msgDict["userName"]) response = { "Header": { "status": "fail", "module": "admin" }, "Body": { "message": "your comapny is rejected", "data": "" }, "Signature": { "signature": "", "Key": "" } } return response else: self.log.logEvent("Admin", 3, "comapny has not been approved", clientId, msgDict["userName"]) response = { "Header": { "status": "fail", "module": "admin" }, "Body": { "message": "your comapny has not been approved", "data": "" }, "Signature": { "signature": "", "Key": "" } } return response except Exception as expc: self.log.logEvent("Admin", 0, "occured exception is " + str(expc), clientId, msgDict["userName"]) # self.syslog.eventHandle("admin","exception","exception on admin module"+str(expc)) def editUser(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 = {"employeeid": msgDict["employeeId"]} changDist = {} for key in msgDict: if key == "emplyeeId": continue else: changDist[key.lower()] = (msgDict[key]) try: if adminDb.editData("clientusers", changDist, condition): self.log.logEvent( "Admin", 2, msgDict["employeeId"] + "user edited successfully", clientId, sessionMange.session[sessionkey]["userid"]) # datalis = ["fullname","employeeid","designation","emailid","userrole",'archive'] # adminDb.fetchData("clients",datalis) response = { "Header": { "status": "success", "module": "admin" }, "Body": { "message": "user deatils edited successfully", "data": "" }, "Signature": { "signature": "", "Key": "" } } return response else: self.log.logEvent("Admin", 2, "user cant edited", clientId, sessionMange.session[sessionkey]["userid"]) response = { "Header": { "status": "success", "module": "admin" }, "Body": { "message": "user deatils can't edited ", "data": "" }, "Signature": { "signature": "", "Key": "" } } return response except Exception as expc: self.log.logEvent("Admin", 0, "occured exception is " + str(expc), clientId, sessionMange.session[sessionkey]["userid"]) # self.syslog.eventHandle("admin","exception","exception on admin module",str(expc)) def deleteUser(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 " datdict = {"employeeid": msgDict["employeeId"]} try: if msgDict["employeeId"] == "kcemp1001": response = { "Header": { "status": "success", "module": "admin" }, "Body": { "message": "admin can't be delete", "data": "" }, "Signature": { "signature": "", "Key": "" } } return response else: if adminDb.updateTable(delete, "clientusers", datdict): self.log.logEvent( "Admin", 2, msgDict["employeeId"] + "Client user deletd successfully", clientId, sessionMange.session[sessionkey]["userid"]) response = { "Header": { "status": "success", "module": "admin" }, "Body": { "message": "user delete successfully", "data": "" }, "Signature": { "signature": "", "Key": "" } } return response #self.listClientUser() else: self.log.logEvent( "Admin", 2, msgDict["employeeId"] + "Client can't user deleted ", clientId, sessionMange.session[sessionkey]["userid"]) response = { "Header": { "status": "success", "module": "admin" }, "Body": { "message": "user can't delete", "data": "" }, "Signature": { "signature": "", "Key": "" } } return response except Exception as expc: self.log.logEvent("Admin", 0, "occured exception is " + str(expc), clientId, sessionMange.session[sessionkey]["userid"]) # self.syslog.eventHandle("admin","exception","exception on admin module",str(expc)) def archiveUser(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() archive = " set archive = 'True' where " admin = Admin() datdict = {"employeeid": msgDict["employeeId"]} try: if msgDict["employeeId"] == "kcemp1001": response = { "Header": { "status": "success", "module": "admin" }, "Body": { "message": "admin can't be archived", "data": "" }, "Signature": { "signature": "", "Key": "" } } return response else: if adminDb.updateTable(archive, "clientusers", datdict): self.log.logEvent( "Admin", 2, msgDict["employeeId"] + "Client archived successfully", clientId, sessionMange.session[sessionkey]["userid"]) response = { "Header": { "status": "success", "module": "admin" }, "Body": { "message": "user archived successfully", "data": "" }, "Signature": { "signature": "", "Key": "" } } return response else: self.log.logEvent( "Admin", 2, msgDict["employeeId"] + "Client canot archived", clientId, sessionMange.session[sessionkey]["userid"]) response = { "Header": { "status": "fail", "module": "admin" }, "Body": { "message": "user can't archived ", "data": "" }, "Signature": { "signature": "", "Key": "" } } return response except Exception as expc: self.log.logEvent("Admin", 0, "occured exception is " + str(expc), clientId, msgDict["employeeId"]) # self.syslog.eventHandle("admin","exception","exception on admin module",str(expc) def unArchiveUser( self, clientId, msgDict, ): 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() archive = " set archive = 'False' where " admin = Admin() datdict = {"employeeid": msgDict["employeeId"]} try: if adminDb.updateTable(archive, "clientusers", datdict): self.log.logEvent( "Admin", 2, msgDict["employeeId"] + "Client archived successfully", clientId, sessionMange.session[sessionkey]["userid"]) response = { "Header": { "status": "success", "module": "admin" }, "Body": { "message": "user unarchived successfully", "data": "" }, "Signature": { "signature": "", "Key": "" } } return response else: self.log.logEvent( "Admin", 2, msgDict["employeeId"] + "Client canot archived", clientId, sessionMange.session[sessionkey]["userid"]) response = { "Header": { "status": "fail", "module": "admin" }, "Body": { "message": "user can't unarchived ", "data": "" }, "Signature": { "signature": "", "Key": "" } } return response except Exception as expc: self.log.logEvent("Admin", 0, "occured exception is " + str(expc), clientId, sessionMange.session[sessionkey]["userid"]) # self.syslog.eventHandle("admin","exception","exception on admin module",str(expc)) def editList(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 = {"employeeid": msgDict["employeeId"]} datalis = [ "fullname", "employeeid", "designation", "emailid", "userrole", 'archive' ] cliList = adminDb.fetchData("clientusers", datalis, condition) infolist = [] try: for info in cliList: for tup in info: infolist.append(tup) role = adminDb.fetchData("permission", ["rolename", "roleid"]) infolist.append(role) self.log.logEvent("Admin", 2, "edit button wanted listed successfully", clientId, sessionMange.session[sessionkey]["userid"]) response = { "Header": { "status": "success", "module": "admin" }, "Body": { "message": "user edit list", "data": infolist }, "Signature": { "signature": "", "Key": "" } } return response except Exception as expc: self.log.logEvent("Admin", 0, "occured exception is " + str(expc), clientId, sessionMange.session[sessionkey]["userid"]) # self.syslog.eventHandle("admin","exception","exception on admin module",str(expc)) 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"]) # self.syslog.eventHandle("admin","exception","exception on admin module",str(expc)) 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"]) # self.syslog.eventHandle("admin","exception","exception on admin module",str(expc)) def userProfile(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] dbCompanyname = masterDb.fetchData("regusers", ["companyname"], cond) print(".................", dbData) adminDb = DatabaseAgent(clientId, clientId, conf.host, password, 5432) adminDb.initConnection() conditions = {"employeeid": msgDict["employeeId"]} detail = ["fullname", "employeeid", "userrole", "designation"] self.log.logEvent("Admin", 0, "user profile showed", clientId, msgDict["employeeId"]) try: responseData = adminDb.fetchData("clientusers", detail, conditions) print("response data", responseData) responseData.append(dbCompanyname[0][0]) response = { "Header": { "status": "success", "module": "admin" }, "Body": { "message": "user profile", "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"]) # self.syslog.eventHandle("admin","exception","exception on admin module",str(expc)) ######################################################companyprofile####################################################### def companyProfile(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: compnydata = self.fetchCompanySummary(adminDb) projectsColl = self.fetchProjectsSummary(adminDb) finalList = [] finalList.append(list(compnydata)) finalList.append(list(projectsColl)) self.log.logEvent("Admin", 2, "Company pofile sended successfully", clientId, sessionMange.session[sessionkey]["userid"]) print("final list is...", finalList) response = { "Header": { "status": "success", "module": "admin" }, "Body": { "message": "companyprile", "data": finalList }, "Signature": { "signature": "", "Key": "" } } return response except Exception as expc: self.log.logEvent("Admin", 0, "occured exception is " + str(expc), clientId, sessionMange.session[sessionkey]["userid"]) # self.syslog.eventHandle("admin","exception","exception on admin module",str(expc)) def fetchCompanySummary(self, dbAgent): condition = {"userrole": "Admin"} dataList = ["fullname", "employeeid", "designation", "companyname"] try: return dbAgent.fetchData("clientusers", dataList, condition) except Exception as expc: self.log.logEvent("Admin", 0, "occured exception is " + str(expc), clientId, sessionMange.session[sessionkey]["userid"]) # self.syslog.eventHandle("admin","exception","exception on admin module",str(expc)) def fetchProjectsSummary(self, dbAgent): projCollection = [] projectData = dbAgent.fetchData("projects", ["Projectname", "projectid"]) # print("\n\n\n") try: for i in range(len(projectData)): cond = {"projectid": projectData[i][1]} curSite = dbAgent.fetchData("sites", ["sitenames"], cond) lCount = dbAgent.fetchData("sites", ["numOfLabourer"], cond) # print("\n\n\nSites:::::::::::: ", curSite) # print("\nSites:::::::::::::: ", curSite[0]) # print("\nSites:::::::::::::: ", curSite[0][0]) projectSummary = [[], []] for j in range(len(curSite)): # print ("\n\n\n\nJ::::::: ", j) sitesList = curSite[j][0] labourerList = lCount[j][0] projectSummary[-1].append(sitesList) projectSummary[-2].append(labourerList) projectSummary.insert(0, projectData[i][0]) projCollection.append(projectSummary) #del labourerList[:] #del sitesList[:] # print("Project Summary:::::::::::::::::::::::::::::::: ", projectSummary) # print("sites.......... ",sitesList) # print("lab........................ ",labourerList) # print("\n\n\n") print("PROJECTS CONTAINER:::::::::::::::::::::::::: ", projCollection) return projCollection except Exception as expc: self.log.logEvent("Admin", 0, "occured exception is " + str(expc), clientId, sessionMange.session[sessionkey]["userid"]) # self.syslog.eventHandle("admin","exception","exception on admin module",str(expc)) #################################################################permissions######################################### ##################################################################attendance############################################################################ ######################################################################company management################################################ # try: # reval # except Exception as expc: # print("oocured exception is",expc) # admin = Admin() # print("companyprofile.....",admin.companyProfile("kec119","karthiban")) # # print(admin.classList("sessionkey")) # # # print("....................",admin.labbourerAddlist("karthiban")) # # admin.roleList("sessionkey") # # print("list is..........",admin.listRoles("sessionkey")) # # print("datasss.....................................",admin.listRoles()) # # sessions["xyzabcd"] = ["karthiban","karthi007"] # # # admin.adminRegister({"userName":"******","fullName":"karthibanvediraj","emailId":"*****@*****.**","companyName":"admin","employId":"k1551","designation":"softwaredeveloper","password":"******"}) # # admin.createRoles() # # ###################labourer reg################################### # # data = {"labourername":"spartan","callbyname":"spartan","gender":"male","dateofbirth":"07/07/1997","fathername":"spartan","bloodgroup":"a1+","nextofkin":"ben","contactnumberofnextofkin":"155525145522","mothertounge":"tamil","addressline1":"address","addressline2":"somthing2","addressline3":"somthing","village":"newyear","state":"newyark","country":"usa","pincode":"600000" ,"mobilenumber":"666575454654656","residancephonenumber":"456518555472320","emergencyphonenumber":"45545554360","dateofjoining":"09/04/1993" ,"migrantworker":"yes" ,"siteid":"usa" ,"siteofjoining":"05/03/2019","designation":"admin","labourerclass":"best","wageclass":"good","documenttype":"adhar","documentnumber":"2585685758120","nameasperdoc":"spartan","bankname":"national","ifsccode":"55365845435520","backaccountnumber":"546546544420","brancname":"usa","nameinbank":"indian"} # # print("datais",admin.labourerReg(data)) # ###############################################labourerlist######################################## # #print("list labourer",admin.labourerInfo()) # ######################labourer change############################################################## # # data = {"labourerId":""} # shift = {"shiftstart":"12:00","shiftend":"07:00","break1start":"00:00","break1end":"04:00","lunchbreakstart":"03:00","lunchbreakend":"00:00","break2start":"00:00","break2end":"04:00"} # # admin.labourerChange() # admin.shiftCreation(shift,"sessionkey") # #print("list of shift",admin.shiftList()) # # shiftedit = {"shiftId":"shift1001","lunchstart":"07:00"} # # print("list of shift",admin.shiftEdit(shiftedit)) # # shiftdelete = {"shiftId":"shift1003"} # # print("list of shift",admin.shiftDeleted(shiftdelete)) # # print("company profile page",admin.shiftAssingn(shiftdelete)) # # print("njnkjnbkjbkjbkj",admin.companyProfile()) # #