def update_announcement(aid): try: if request.json: for key in announcement_keys: if key not in request.json: return jsonify({ "error": "Paramenter {0} missing in request".format(key) }) if int(request.json['platformid']) > 0: result = dbm.edit_platform_announcement( request.json['a_img'], request.json['a_title'], request.json['active'], request.json['aid'], request.json['platformid']) else: result = dbm.edit_store_announcement(request.json['a_img'], request.json['a_title'], request.json['active'], request.json['aid']) return jsonify({'aid': result}) else: return bad_request() except Exception as e: print e.message return internal_server_error()
def update_payment(userid, payment_methodid): try: if request.method == 'PUT': if request.json: payment_keys = post_payment_keys payment_keys.append('ppreferred') for key in payment_keys: if key not in request.json: return missing_parameters_error() errors = validate_payment(request.json) if errors: return jsonify({'Errors': errors}), 400 billing_addressid = dbm.fetch_user_preferences( userid)['billing_address']['aid'] if billing_addressid: pid = dbm.update_payment_method(userid, payment_methodid, request.json, billing_addressid) return jsonify({'payment_methodid': pid}), 201 else: return jsonify({ 'Error': 'Preferred Billing Address Not Found For User {0}'. format(userid) }), 400 return bad_request() elif request.method == 'DELETE': result = dbm.deactivate_user_payment_method( userid, payment_methodid) if result: return jsonify(result) return bad_request() except Exception as e: print e.message return internal_server_error()
def __init__(self, windowSize): self.windowSize = windowSize self.dbManager = DBManager() self.dictionary = self.dbManager.selectDictionaryDB() self.isWindowValid = self.dbManager.isWindowValid(self.windowSize) self.analyzer = Analyzer(self.windowSize, self.dictionary) self.analyzer.fillMatrixSearch(self.dbManager.coocToDictWindow(self.windowSize))
def signIn(sock): while True: # 接受用户名 try: userName = sock.recv(20).decode(coding) # Windows 用户断开链接 except ConnectionResetError: return sock # Linux 用户断开链接 if not userName: return sock # 用户不存在返回False 提示 注册 if not DBManager.existent(userName): sock.send('0'.encode(coding)) if sock.recv(1).decode(coding) == 'Y': # 注册函数 signUp(sock) continue else: sock.send('1'.encode(coding)) break for x in range(3): # 等待登陆密码 signInPasswd = sock.recv(32).decode(coding) # 匹配登陆密码 match = DBManager.match(userName, signInPasswd) if match: sock.send('1'.encode(coding)) break sock.send('0'.encode(coding)) if x == 2: return sock # 保存客户端信息 sockDict[userName] = sock return userName
def get_patients(): # Can't be triggered by normal app use if not all(param in request.args for param in ('test_selection', )): return jsonify({ 'errors': { 'missing_fields': 'Please supply all required fields' } }), 400 tester_id = DBManager.get_logged_in_tester_id(request.cookies['sessionID']) # tester_id should never be None; this can only happen if the # tester is deleted after the first DBManager function call # (i.e. in is_logged_in) but before the second if tester_id == None: tester_id = -1 patient_type = request.args.get( 'patient_type') if 'patient_type' in request.args else None test_selection = int(request.args.get('test_selection')) == 1 patients = DBManager.get_patients(tester_id, patient_type=patient_type, test_selection=test_selection) return jsonify({"Patients": patients})
def POST(self): """ This function generates different html pages based on the buttons pressed by the user. From this screen, the player can choose to load a previous game or start a new one. Parameters: None Returns: None """ playerStateObject = PlayerState() #Update the player state action = web.input() #Create web.input() to save any information the user if action['new'] == 'storyScreen': #Checks to see if the user pressed the button to send them to the character selection screen raise web.seeother('/story') #If the above is true this line renders charScreen.html elif action['new'] == 'loadScreen': #Checks to see if the user pressed the button to load a previous game if None != DBManager.getPlayerCharacterActionFromDB(playerStateObject.player_id): #If the above is true this line checks to see if the player has chosen a character in their previous game if None != DBManager.getPlayerStoryActionFromDB(playerStateObject.player_id): #If the above is true this line checks to see if the player has chosen a story in their previous game raise web.seeother('/load') #If the above is true this line renders gameScreen.html else: raise web.seeother('/load') #If the conditional on line 65 is false then the story selection screen for the players chosen character is rendered else: raise web.seeother('/load') #If the conditional on line 64 is false then the character selection screen is rendered elif action['new'] == 'aboutScreen': #This conditional checks to see if the user pressed the button to go to the about screen raise web.seeother('/about') #If the above conditional is true this line renders aboutScreen.html elif action['new'] == 'helpScreen': #This conditional checks to see if the user pressed the button to go to the help screen raise web.seeother('/help') #If the above is true then helpScreen.html is rendered
def unlock_patient(): # Can't be triggered by normal app use if not all(param in request.json for param in ('patient_id', 'password')): return jsonify({ 'errors': { 'missing_fields': 'Please supply all required fields' } }), 400 patient_id = int(request.json['patient_id']) password = request.json['password'] password_hash = DBManager.get_patient_password_hash(patient_id) is_blind = DBManager.is_patient_blind(patient_id) if password_hash and check_password_hash(password_hash, password) and not is_blind: tester_id = DBManager.get_logged_in_tester_id( request.cookies['sessionID']) DBManager.unlock_patient(tester_id, patient_id) response = jsonify({'unlock_successful': True}) else: response = jsonify({'unlock_successful': False}) return response, 201
def user_address(userid): try: if request.method == 'GET': address = dbm.fetch_user_address(userid) if address: return jsonify(address) return not_found() elif request.method == 'POST': if request.json: address_keys = post_address_keys address_keys.append('apreferred') address_keys.append('atype') for key in address_keys: if key not in request.json: return missing_parameters_error() errors = validate_address(request.json) if errors: return jsonify({'Errors': errors}), 400 if request.json[ 'atype'] == 'billing' and 'pid' not in request.json: return jsonify({'Errors': "Missing Payment Method."}), 400 new_address_id = dbm.create_user_address(userid, request.json) return jsonify({'aid': new_address_id}), 201 else: return missing_parameters_error() except Exception as e: print e.message return internal_server_error()
def daily_job(): DBManager.update_today() content = InfoHandler.pack_daily_content() receivers = DBManager.get_auditors() MailSender.send(receivers, 'Daily LeetCode Notice', content, True) DBManager.update_yestoday() print("daily job done") return
def lista_insert(self): banco = DBManager() listabanco = banco.consulta_tabela() for pos, linha in enumerate(listabanco): self.__lista_listbox[0].insert(END, listabanco[pos][0]) self.__lista_listbox[1].insert(END, listabanco[pos][1]) self.__lista_listbox[2].insert(END, listabanco[pos][2]) self.__lista_listbox[3].insert(END, listabanco[pos][4])
def minus_job(user): """ Removes a job to a user :param user: """ userdb = DBManager.get_user(user) new_jobs = userdb['jobs'] - 1 DBManager.update_user(user, new_jobs, userdb['reputation'])
def plus_job(user): """ Adds a job to a user :param user: """ userdb = DBManager.get_user(user) new_jobs = userdb['jobs'] + 1 DBManager.update_user(user, new_jobs, userdb['reputation'])
def newGenre(series): genres = series['genres'].strip('|').split('|') for genre in genres: DB.storeData('genre',{'tag':genre,'genreid':'NULL'}) result = DB.selectWhere('genre','tag',genre,genreid) if result: DB.storeData('genre_relation',{'genreid':result[0][0] ,'seriesid':series['seriesid']})
def set_veiculo(self): data = datetime.today() banco = DBManager() banco.inserir_veiculo(self.__edPlaca.get().upper(), data, self.__tipo) messagebox.showinfo('Aviso', 'Veículo inserido com sucesso!') self.__edPlaca.focus_force() self.__edPlaca.delete(0, END)
def __init__(self): print ("Calling parent constructor") self.con = DBManager.connectDB() self.engine = DBManager.createEngine() self.cur = self.con.cursor() self.qd_exception_list = [] self.fr_exception_list = []
def minus_rep(user, decrease=1): """ Removes rep from a user :param decrease: :param user: """ userdb = DBManager.get_user(user) new_rep = userdb['reputation'] - decrease DBManager.update_user(user, userdb['jobs'], new_rep)
def __init__(self): self._DBHandle = DBManager() self._DBCur = self._DBHandle.getDBCur() self._DBCon = self._DBHandle.getDBCon() self._URLInstance = URLBuilder() self._code = "" self._Component = "" self._fileSet = set() pass
def plus_rep(user, increase=1): """ Adds rep to a user :param increase: :param user: """ userdb = DBManager.get_user(user) new_rep = userdb['reputation'] + increase DBManager.update_user(user, userdb['jobs'], new_rep)
def pagar(self): banco = DBManager() # recupera a id do usuário do banco em forma de tupla id_usuario = banco.consulta_tabela_funcionarioid(self.__usuario) #registra no banco os dados do pagamento banco.pagar(Calcular.__placa, self.setPlaca(), id_usuario[0]) #limpa a caixa de texto edplaca self.__edplaca.delete(0, END) #mensagem de aviso para pagamento realizado messagebox.showinfo("Aviso", "Pagamento registrado!")
def applyJob(self, jobid, jobname): result = messagebox.askquestion( "Applying for job: " + jobname, "Your resume will be shared to the poster. Apply?") if result == 'yes': db = DBManager() try: userInfo = db.run( "SELECT * FROM APPLICANT WHERE USERNAME = %s;", (self.user.username, )) db.run( "INSERT INTO APPLICATIONS VALUES(%s, %s, %s, %s, %s, %s);", ( int(jobid), userInfo[0][2], userInfo[0][0], userInfo[0][1], userInfo[0][3], userInfo[0][4], )) db.close() messagebox.showinfo("APPLIED", "Your application has been sent.") except Exception as e: print(e) db.close() messagebox.showerror("ERROR", e)
def __get_hora_entrada(self, placa): try: banco = DBManager() entrada = banco.consulta_placa(placa) Calcular.__entrada = datetime.strptime(entrada[0], '%Y-%m-%d %H:%M:%S.%f') return Calcular.__entrada except TypeError: messagebox.showinfo("Aviso", "Placa não consta no sistema") self.__edplaca.delete(0, END) self.__edplaca.focus_force()
def create_test(): # Can't be triggered by normal app use if not all(param in request.json for param in ('app', 'patient_id', 'test_date')): return jsonify({ 'errors': { 'missing_fields': 'Please supply all required fields' } }), 400 test = { 'app': request.json['app'], 'patient_id': int(request.json['patient_id']), 'tester_id': DBManager.get_logged_in_tester_id(request.cookies['sessionID']), 'test_date': request.json['test_date'] } if test['patient_id'] == 0: test['patient_id'] = DBManager.create_patient({ 'patient_type': 'anonymous', 'visible_patient_id': datetime.datetime.fromtimestamp( time.time()).strftime('%Y-%m-%d %H:%M:%S'), 'group': '', 'name': '', 'dob': '', 'notes': '', 'gender': '', 'password_hash': '' }) test['details'] = {} for key, value in request.json.iteritems(): if key not in test: test['details'][key] = value try: globals()[test['app'] + '_post_process'](test) except KeyError, NameError: # Post-processing functions aren't defined for all the games pass
def collect(): print('\nCollecting @ ', datetime.now()) # current time start = t.time() articles_list = Scrape.get_articles() # scraping data DBM.populate_db(articles_list) # saving to database DBM.prune_db(days) # pruning articles print(str(t.time() - start), 'seconds') # timing the execution print('Next collection @ ~', datetime.now() + timedelta(minutes=min_interval), '\n') # approx. next collection time
def __init__(self): self.janela = Tk() self.banco = DBManager() self.config() self.listaNome() self.lista() Button(self.janela, text="Voltar", command=self.voltar).grid(row=0, column=2) self.janela.mainloop()
def user_preferences(userid): try: if request.method == 'GET': preferences = dbm.fetch_user_preferences(userid) if preferences: return jsonify(preferences) return not_found() elif request.method == 'PUT': if ('shipping_addressid' or 'billing_addressid' or 'cid') not in request.json: return missing_parameters_error() errors = validate_user_preferences(request.json, userid) if errors: return jsonify({'errors': errors}), 400 if 'shipping_addressid' in request.json: dbm.update_user_preferred_shipping( request.json['shipping_addressid'], userid) if 'billing_addressid' in request.json: dbm.update_user_preferred_billing( request.json['billing_addressid'], userid) if 'cid' in request.json: dbm.update_user_preferred_payment(request.json['cid'], userid) preferences = dbm.fetch_user_preferences(userid) if preferences: return jsonify(preferences) return bad_request() except Exception as e: print e.message return internal_server_error()
def signUp(sock): while True: newUser = sock.recv(20).decode(coding) # 查询用户是否存在 # 存在 if DBManager.existent(newUser): sock.send('0'.encode(coding)) continue # 不存在 发送1 接收密码 sock.send('1'.encode(coding)) passwd = sock.recv(32).decode(coding) DBManager.insert('userInfo', newUser, passwd) print('新用户:%s' % newUser) # 日志 break
def delete_from_user_wish_list(userid, productid): try: if request.method == 'DELETE': in_wish_list = dbm.wish_list_contains( productid=productid, userid=userid)['product_in_wishlist'] if in_wish_list: dbm.remove_from_wish_list(productid=productid, userid=userid) wish_list = dbm.fetch_user_wish_list(userid=userid) return jsonify(wish_list) else: not_found() elif request.method == 'POST': in_wish_list = dbm.wish_list_contains( productid=productid, userid=userid)['product_in_wishlist'] if not in_wish_list: dbm.add_product_to_user_wishlist(productid=productid, userid=userid) wish_list = dbm.fetch_user_wish_list(userid=userid) return jsonify(wish_list) else: return jsonify({ 'error': 'Product {0} is already in user {1} wish list.'.format( productid, userid) }), 400 except Exception as e: print e return internal_server_error()
class Patio(object): def __init__(self): self.janela = Tk() self.banco = DBManager() self.config() self.listaNome() self.lista() Button(self.janela, text="Voltar", command=self.voltar).grid(row=0, column=2) self.janela.mainloop() def voltar(self): self.janela.destroy() def listaNome(self): pass def config(self): self.janela.title("Listagem de Veiculos no patio") self.janela.geometry("620x200+450+200") lb = Label(self.janela, text="Veiculos com pagamento em aberto") lb.grid(row=0, column=0, columnspan=2) def lista(self): self.listaplaca = Listbox() self.listaentrada = Listbox() self.listapago = Listbox() self.listatipo = Listbox() self.listas = [["Placa", self.listaplaca], ["Entrada", self.listaentrada], ["Pago", self.listapago], ["Tipo", self.listatipo]] for p, linha in enumerate(self.listas): Label(self.janela, text=self.listas[p][0]).grid(row=2, column=p) linha[1] = Listbox(self.janela, width=25) linha[1].grid(row=3, column=p) self.lista_insert(p) def lista_insert(self, pos): query = [ self.banco.consulta_tabela_veiculo_placa(), self.banco.consulta_tabela_veiculo_entrada(), self.banco.consulta_tabela_veiculo_pago(), self.banco.consulta_tabela_veiculo_tipo() ] for i in query[pos]: self.listas[pos][1].insert(END, i)
def GET(self): """ This function renders homeScreen.html and checks to see if player data exists in the database. If not, this is a new player and new data is inserted into the database. If there is player data then the existing player state is updated. Parameters: None Returns: None """ #if not DBManager.checkforExistingPlayer(web.ctx.ip): #Checking to see if current player has played before DBManager.getPlayerIP(web.ctx.ip) #If the above is true save the players ip address in the database playerStateObject = PlayerState() #Updating the player state return self.render.homeScreen() #Render homeScreen.html
def POST(self): """ This function checks to see if the home button was pressed and if it was homeScreen.html is rendered. If not, lastScreen.html stays rendered. Parameters: None Returns: None """ playerStateObject = PlayerState() #Updating the player state if web.input()['home']=='home': #Checks to see if the player pressed the home button raise web.seeother('/end') #If the above is true homeScreen.html is rendered else: DBManager.insertPlayerStepAction(playerStateObject.player_id) #If the player did not hit the home button this line records the action the player took and saves it in the database raise web.seeother('/end') #This line renders endScreen.html
def on_trigger(submit_id, submit_author, comment): """ On Trigger of bot :param submit_id: :param submit_author: :param comment: """ cid = comment.id try: cauthor = comment.author.name except AttributeError: return cbody = comment.body.lower() message = cbody.split(OfferBot.TRIGGER)[1].split("\n")[0] if "accept" in message: # UserManager.plus_job(cauthor) reply = get_response_accept(cauthor, submit_author) elif "plusrep" in message: # UserManager.plus_rep(cauthor) reply = get_response_plus_rep(cauthor, submit_author) elif "minusrep" in message: reason = message.split("minusrep")[1] reply = get_response_minus_rep(cauthor, submit_author, reason) elif "done" in message: reply = get_response_done(cauthor, submit_author) else: reply = get_response_user(cauthor) if UserManager.get_rep_level(DBManager.get_user(cauthor)['reputation']) == "Scammer": OfferBot.bot_reply(comment, get_response_scammer(cauthor)) OfferBot.bot_reply(comment, reply)
def GET(self): """ This function dynamically renders storyScreen.html when the user types in the appropriate url or navigates to the page by interacting with the website. Parameters: None Returns: None """ playerStateObject = PlayerState() #Updating the player state story_ids = DBManager.getStoriesFromDB(playerStateObject.player_id) #Getting story data from the database and saving it to a variable story_titles=DBManager.getStoryTitles(playerStateObject.player_id) #Getting story titles from the database and saving it to a variable walk_level=DBManager.getStoryData()[0] kid_friendly=DBManager.getStoryData()[1] return self.render.storyScreen(story_ids, story_titles, walk_level, kid_friendly) #Using the above two variables to dynamically generate storyScreen.html
def dom0Info(xenHost): tool = Tools() db = DBManager() dom0 = Dom0(xenHost) # Check if dom0 contain dom0_info on db dom0ID = db.returnDom0Id(dom0) if dom0ID != None: memory = psutil.phymem_usage() cpuTotal = psutil.cpu_percent(interval=1, percpu=True) disk = psutil.disk_usage("/") dom0.id = dom0ID[0] dom0.memTotal = tool.convertBytes(memory.total) dom0.memUsed = tool.convertBytes(memory.used) dom0.memFree = tool.convertBytes(memory.free) dom0.memPercent = memory.percent dom0.diskTotal = tool.convertBytes(disk.total) dom0.diskUsed = tool.convertBytes(disk.used) dom0.diskFree = tool.convertBytes(disk.free) dom0.diskPercent = disk.percent dom0.cpu = tool.returnCpuInfo(cpuTotal) if db.checkDom0Info(str(dom0ID[0])) == None: db.insertDom0Info(dom0) else: db.updateDom0Info(dom0) else: print "Invalid dom0"
def POST(self): """ This function checks to see if the player has chosen a story and if they have the story choice is saved. Parameters: None Returns: None """ playerStateObject = PlayerState() action = web.input() if action['story']=="back": raise web.seeother('/') else: title=action['story'] story_id=DBManager.getStoryIDFromTitle(title) DBManager.insertPlayerStoryAction(playerStateObject.player_id,story_id) raise web.seeother('/game')
def GET(self): """ This function dynamically generates the steps of the game until there are no more steps. The elements of this webpage change based on the players progress and their Character/Story choices. Parameters: None Returns: None """ playerStateObject = PlayerState() if DBManager.needLastScreen(playerStateObject.player_id)==True: print "need last" raise web.seeother('/last') else: print "not last" title, text, hint1, hint2, hint3, answertext = DBManager.getGameScreenDataFromDB(playerStateObject.player_id) #Assigning several variables by pulling data from the database in order to dynamically generate different bodies of text for the user return self.render.gameScreen(title, text, hint1, hint2, hint3, answertext) #Rendering the gameScreen.html
def __init__(self): # Mode actuel dans les différentes pièces self.currentMode = {"A": "AUTO", "B": "AUTO", "C": "AUTO", "D": "AUTO"} # Température par défaut des différentes pièces self.defaultTemp = {"A": 18, "B": 18, "C": 18, "D": 18} self.setup_gpio(param.GPIO) self.db = DBManager()
def POST(self): """ This function checks to see if the player has chosen a story and if they have the story choice is saved. Parameters: None Returns: None """ playerStateObject = PlayerState() #Updating the player state action = web.input() #Creating web.input() object to save any from data input by the user if action['story']== "back": #Checks to see if the player pressed the back button raise web.seeother('/home') #If the above is true then the charScreen.html is rendered else: title= action['story'] story_id=DBManager.getStoryIDFromTitle(title) print story_id DBManager.insertPlayerStoryAction(playerStateObject.player_id,story_id) #If the above is true the story selection is inserted into the database raise web.seeother('/game') #Rendering gameScreen.html
def registerVMs(self, xenapi, session, host): hostRef = xenapi.session.get_this_host(session["Value"], session["Value"])["Value"] domURef = xenapi.host.get_resident_VMs(session["Value"], hostRef)["Value"] vmsList = [] for vmRef in domURef: # dom0 will not be shown if vmRef != "00000000-0000-0000-0000-000000000000": vmInfoRef = xenapi.VM.get_record(session["Value"], vmRef) vmInfo = vmInfoRef["Value"] if vmInfo["HVM_boot_policy"] == "": vmType = "Para-Virt" else: vmType = "Full-Virt" vmMaxMemory = (int(vmInfo["memory_dynamic_max"]) / 1024) / 1024 vmMetricRef = vmInfo["metrics"] vmMetric = xenapi.VM_metrics.get_record(session["Value"], vmMetricRef) domU = DomU(vmInfo["name_label"], vmType, vmMaxMemory, vmInfo["power_state"], host) vmsList.append(domU) db = DBManager() db.updateDomU(host, vmsList)
def start(): series = DB.dirContent() reqSer = [] reqEp = {} for ser in series: res = selectWhere('series','seriesname',sub('[_\.]',' ',ser),'seriesid') if not : reqSer.append(ser) else: reqEp[ser] = [] for ep in series[ser]: ep['id'] = res[0] if not executeSelectQuery('select * from episode where \ seasonnumber=\'{season}\' and episodenumber=\ \'{episode}\' and seriesid=\'{id}\''.format(**ep)) reqEp[ser].append(ep) if reqSer != [] or reqEp != []: import StoreManager as SM for ser in reqSer: DB.newSeries(ser,series[ser]) DB.newEpisode(reqEp)
def GET(self): """ This function render lastScreen.html when the player either navigates to it by interacting with the website or typing in the appropriate url. Parameters: None Returns: None """ playerStateObject = PlayerState() #Updating the player state title,text = DBManager.getLastScreenDataFromDB(playerStateObject.player_id) #Assigning several variables by pulling data from the database return self.render.lastScreen(text,title) #Rendering lastScreen.html using the variables on line 239
def get_response_plus_rep(user, op): """ OfferBot Tests :param user: """ user_info = DBManager.get_user(user) rep = user_info['reputation'] rep_string = UserManager.get_rep_level(rep) response = Template(config.get("offer", "plus_rep_reply")) response = response.substitute(username=user, username2=op, rep=rep_string, repno=rep) return response
def POST(self): """ This function responds to user input and generates the proper game screens. This function ultimately controls game flow. Parameters: None Returns: None """ playerStateObject = PlayerState() #Updating player state if web.input()['home']=='home': #Checking to see if the player pressed the home button raise web.seeother('/home') #If the above is true then homeScreen.html is rendered else: player_input= web.input()['home'] #Creating web.input() to hold user input information player_input= player_input.lower() #if DBManager.needLastScreen(playerStateObject.player_id, player_input): #Checks to see if the player has reached the end of the game and the final screen need to be displayed # raise web.seeother('/last') #If the above is true then lastScreen.html is rendered DBManager.compareInputToAnswers(playerStateObject.player_id, player_input) #Inserting the action that the player took and inserting that information into the database print "compare input run" raise web.seeother('/game') #Rendering gameScreen.html
def __init__(self, pythonServer, clientSock, addr, sym_key): threading.Thread.__init__(self) self.security = Security() # reference to parent server self.pythonServer = pythonServer # new open socket for client self.clientSock = clientSock # address connection : IP and Port self.addr = addr self.sym_key = None # Dictionary of ptotocols functions : Key - level Value - referance to function # self.operFnPtrDict = { 1 : self.oper1Fun, 2 : self.oper1Fun } self.AES=AESCrypt() self.DBManager = DBManager()
def newSeries(name, pathDict, epFlag=0): """ newSeries(String) downloads the series info and stores it to the DB. """ seriesWhole = API.getSeries(name=name) series = seriesWhole['series'] episodes = seriesWhole['episodes'] if not epFlag: newGenre(series) newActors(series) newBanners('banner', series) DB.storeData('series', series) for episode in episodes: for ep in pathDict: if (ep['season'] == episode['seasonnumber'] and ep['season'] == episode['episodenumber']): episode['path'] = ep['path'] else: episode['path'] = 'NULL' if episode['path'] != 'NULL' or not epFlag: _storeEpisode(episode)
def bot_post_logic(sid, sauthor, comment): """ Logic for each post :param sid: :param sauthor: :param comment: :return: """ cid = comment.id try: cauthor = comment.author.name except AttributeError: return if cauthor.lower() == REDDIT_CLIENT.user.name.lower(): return if DBManager.is_oldpost(cid): return DBManager.add_oldpost(cid) cbody = comment.body.lower() if TRIGGER.lower() in cbody: OfferManager.on_trigger(sid, sauthor, comment)
def __init__(self): """ The player state class is initialized for each player which keeps a record of the player within the DB. This allows for easy access to the player's information through DBManager. Parameters: Character: The player's chosen character. Story: The player's chosen story. Returns: Something. """ self.player_data = DBManager.getPlayerFromDB(web.ctx.ip) #Pulling all player data from the database via a unique player ip address self.player_id = self.player_data[0] #Pull the first element from the player_data array to obtain a player's unique id
class DataCollecter(): def __init__(self): self._DBHandle = DBManager() self._DBCur = self._DBHandle.getDBCur() self._DBCon = self._DBHandle.getDBCon() self._URLInstance = URLBuilder() self._code = "" self._Component = "" self._fileSet = set() pass def UpdateStocks(self, mark, IDHead, IDTail): try: self._DBCur.execute('''CREATE TABLE collections ''' + ''' (code text, recordtype text, date text, holders real, holderschangeper real, averagehold real, averageholdchangeper real, scr text, price real, averageamount real, top10hold real, top10outstandinghold real)''') except: pass countTmp = 0 for x in range(IDHead,IDTail): urlToGet = self._URLInstance.GetURL(self.BuildCode(mark, x, 1)) try: content = urllib2.urlopen(urlToGet).read() time.sleep(3) countTmp += 1 if countTmp == 50: time.sleep(6) countTmp = 0 except: continue self._ContentInstance = EastmoneyContent() self._ContentInstance.feed(content) self._ContentInstance.handle_listmatrix(self.BuildCode(mark, x, 0), "F10") #-----------------begin sqlite---------------------------- if self._ContentInstance.listmatrix != []: for iteminlistmatrix in self._ContentInstance.listmatrix: codeTmp = iteminlistmatrix[0] dateTmp = iteminlistmatrix[2] executeSQL = 'select * from collections where date = \"' + dateTmp + '\" and code = \"' + codeTmp + '\"' self._DBCur.execute(executeSQL) SQLTmp = self._DBCur.fetchall() if SQLTmp == []: executeSQL = 'INSERT INTO collections VALUES (?,?,?,?,?,?,?,?,?,?,?,?)' self._DBCur.execute(executeSQL, iteminlistmatrix) self._DBCon.commit() print " done\n" self._DBCon.commit() else: print " has none\n" def BuildCode(self, mark, x, mix): if mark == "sh": self._code = "6" + str(x)[-5:] self._Component = mark + self._code if mark == "sz": self._code = str(x)[-6:] self._Component = mark + self._code if mix == 1: return self._Component if mix == 0: return self._code def UpdateStockname(self, filename): x = 0 for line in open(filename): if x == 0 : x += 1 continue x += 1 linesplited = line.split('\t') executeSQL = ' update collections set name = \"' + linesplited[2] + '\" where code = ' + linesplited[1] + ' ' self._DBCur.execute(executeSQL) self._DBCon.commit() pass def NewTab(self, filename): x = 0 for line in open(filename): firstline = [] pricenow = [] if x == 0 : x += 1 firstline = line.split('\t') try: self._DBCur.execute('''CREATE TABLE price ''' + '''(code text, newprice real, toplevel real, toplimitdays real)''') except: pass continue x += 1 linesplited = line.split('\t') executeSQL = 'INSERT INTO price VALUES (?,?,?,?)' pricenow.append(linesplited[1][1:7]) pricenow.append(linesplited[7]) pricenow.append(linesplited[10]) pricenow.append(linesplited[8]) self._DBCur.execute(executeSQL, pricenow) self._DBCon.commit() pass def UpdateStocksHtmls(self, mark, IDList): countTmp = 0 #if not os.path.isdir(mark): # os.makedirs(mark) path = "K:\\codes\\ApplicationStock\\ApplicationStocks\\sh" os.chdir(path) if len(self._fileSet) == 0: for root, dirs, files in os.walk( path ): for fn in files: self._fileSet.add(fn) for x in IDList: ''' for root, dirs, files in os.walk( path ): for fn in files: if fn not in self._fileSet: self._fileSet.add(fn) ''' urlToGet = self._URLInstance.GetURL(self.BuildCode(mark, x, 1)) if urlToGet[-6:] in self._fileSet: continue if os.path.exists(urlToGet[-6:]) == True: continue try: content = urllib2.urlopen(urlToGet).read() time.sleep(1) countTmp += 1 if countTmp == 50: time.sleep(6) countTmp = 0 except: continue fileobj = open(urlToGet[-6:], "wb") fileobj.write(content) fileobj.close() def UpdateStocksHtmlsFinance(self, mark, IDHead, IDTail): countTmp = 0 if not os.path.isdir(mark + "finance"): os.makedirs(mark + "finance") os.chdir( "./" + mark + "finance" + "/") for x in range(IDHead,IDTail): urlToGet = self._URLInstance.GetURL(self.BuildCode(mark, x, 1)) try: content = urllib2.urlopen(urlToGet).read() time.sleep(0) countTmp += 1 if countTmp == 50: time.sleep(6) countTmp = 0 except: continue fileobj = open(urlToGet[-8:], "wb") fileobj.write(content) fileobj.close()
def returnDom0Id(self, host): dom0 = Dom0(host) db = DBManager() db.returnDom0Id(dom0)
def updateDom0(self, host, state): dom0 = Dom0(host) db = DBManager() db.updateDom0(dom0, state)
# # checkHost # Receives: # host -> ip dom0 # def checkHost(host): try: sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM) sock.connect((host, int(xenPort))) sock.close() return 1 except socket.error, err: return 0 # # XOM - Main # dbManager = DBManager() for dom0 in dbManager.returnDom0s(): dom0Manager = Dom0Manager() if (checkHost(dom0[5])): xenApi = xmlrpclib.Server("http://" + dom0[5] + ":" + xenPort) session = Session(xenUser, xenPassword, xenApi).authentication() print "[xom] dom0 " + dom0[5] + " up." dom0Manager.updateDom0(dom0[5],"up") if(session['Status'] == "Success"): dom0Manager.registerVMs(xenApi, session, dom0[5]) else: print "[xom] dom0 " + dom0[5] + " down." dom0Manager.updateDom0(dom0[5],"down")
class MyHouse: # Constructeur def __init__(self): # Mode actuel dans les différentes pièces self.currentMode = {"A": "AUTO", "B": "AUTO", "C": "AUTO", "D": "AUTO"} # Température par défaut des différentes pièces self.defaultTemp = {"A": 18, "B": 18, "C": 18, "D": 18} self.setup_gpio(param.GPIO) self.db = DBManager() # self.i2c = I2CManager() # GPIO configuration def setup_gpio(self, array): GPIO.setmode(GPIO.BCM) # v[0] contains the key # v[1] contains the value for v in array.items(): if isinstance(v[1], dict): self.setup_gpio(v[1]) else: if v[1][0].upper() == "IN": GPIO.setup(v[1][1], GPIO.IN) else: GPIO.setup(v[1][1], GPIO.OUT) # Test si la connexion est activee # Retourne True si internet est activee # Retourne False si non def isInternetOn(self): try: host = socket.gethostbyname("www.google.com") s = socket.create_connection((host, 80), 2) return True except: pass return False # Allume ou eteint le chauffage # room : nom du chauffage # status : True ou False def heat(self, room, status): GPIO.output(param.GPIO["Heating"][room][1], status) # Allume ou eteint la lampe # status : True ou False def setLamp(self, status): GPIO.output(param.GPIO["Lamp"][1], status) # Retourne la temperature d'une pièce def getTemp(self, name): list_room = {"A": 1, "B": 2, "C": 3, "D": 4} temp = 18 # Normalement devrait utiliser l'adc mais fonctionne pas ;( return temp # Sauvegarde la température par défault de la pièce def setDefaultTemp(self, room, temp): self.defaultTemp[room] = temp connection = self.db.getConnection() cursor = connection.cursor() cursor.execute("UPDATE temp_default SET temp_default = %s WHERE room= %s", (temp, room)) cursor.close() # Récupère la température par défaut d'une pièce def getDefaultTemp(self, room): connection = self.db.getConnection() cursor = connection.cursor() cursor.execute("SELECT temp_default FROM temp_default WHERE room = %s", (str(room))) result = cursor.fetchone() requestTemp = result[0] cursor.close() return requestTemp # Permet de récupérer la température pour la chambre à la date donnée def getRequestTemp(self, room, date): connection = self.db.getConnection() cursor = connection.cursor() cursor.execute( "SELECT temp FROM consigne WHERE room = %s AND start_order < %s AND end_order > %s", (str(room), str(date), str(date)), ) result = cursor.fetchone() if result: temp = result[0] cursor.close() return temp connection = self.db.getConnection() cursor = connection.cursor() cursor.execute("SELECT temp_default FROM temp_default WHERE room = %s", (str(room))) result = cursor.fetchone() requestTemp = result[0] print("Request temp :", requestTemp, "in room", room) cursor.close() return requestTemp # Sauvegarde une consigne def setConsigne(self, room, temp, start_timestamp, end_timestamp): self.db.executeUpdate( "INSERT INTO `consigne` (`temp`, `start_order`, `end_order`, `room`) VALUES (%s,%s,%s,%s)", (str(temp), str(start_timestamp), str(end_timestamp), room), ) def setMode(self, room, status): self.currentMode[room] = status # Retourne True ou False si fenetre Ferme ou Ouvert def getWindow(self, name): return GPIO.input(param.GPIO["Windows"][name][1]) # Retourne True ou False si porte Ferme ou Ouvert def getDoor(self, name): return GPIO.input(param.GPIO["Doors"][name][1]) # Régule la maison def regulate(self): date = int(time.time()) # Contient la date du jour requestTempA = self.getRequestTemp("A", date) requestTempB = self.getRequestTemp("B", date) requestTempC = self.getRequestTemp("C", date) requestTempD = self.getRequestTemp("D", date) if self.getTemp("D") > requestTempD or self.getWindow("D"): self.heat("D", False) else: self.heat("D", True) if self.getTemp("B") > requestTempB or self.getWindow("BG") or self.getWindow("BD"): self.heat("B", False) else: self.heat("B", True) if self.getTemp("C") > requestTempC or self.getWindow("C"): self.heat("C", False) else: self.heat("C", True)