def GET(self): i = web.input(id=None, placa=None) try: DB.delete('vehiculos', where="id=" + i.id) except: print "Error Inesperado /deletevehicle:", sys.exc_info() raise web.seeother('/listvehicle')
def update_config_with_env_vars(app_name: str = NBA_APP_NAME) -> dict: """ Gets environment variables starting with the app name given in the config.py file. Based on env getter from my Meteo project. It defaults to the values in config.py and overwrites or appends that dict if an environment variable starts with the <app_name> param. :param app_name: str - name of app, defaults to NBA :return: a dictionary of var name : var value pairs updated with env vars meeting the "starts with <app_name> criteria :rtype: dict """ # copy config.py default DB config dict db_out = DB.copy() logger.debug("Getting environment variables") variables = os.environ logger.debug(f"Filtering for env vars starting with: \"{app_name}\"") filtered = [x for x in list(variables.keys()) if x.startswith(app_name)] logger.info("Setting config values with environment parameters") for key in filtered: # if env var name is the same as cfg var, overwrite it's value if key in list(DB.keys()): db_out[key] = variables[key] # if env var is not in cfg, add it with env value else: db_out[key] = variables[key] logger.info("Config values set") logger.info(db_out) return db_out
def GET(self): i = web.input(id=None) try: DB.delete('usuarios', where="id=" + i.id) except: print "Error Inesperado /deleteuser:", sys.exc_info() raise web.seeother('/listuser')
def GET(self): i = web.input(id=None) try: DB.delete('eventos', where="id=$i.id", vars=locals()) except: print "Error Inesperado /deleteclient:", sys.exc_info() raise web.seeother('/managevents')
def GET(self): i = web.input(id=None, name=None) try: DB.delete('gps', where="id=" + i.id) except: print "Error Inesperado /deletegps:", sys.exc_info() raise web.seeother('/listgps')
def GET(self): i = web.input(id=None) try: DB.update('eventos', where='id=$i.id', admin_state='t', vars=locals()) except: print "Error Inesperado /updateevent:", sys.exc_info() raise web.seeother('/managevents')
def setUp(self): DB.delete('articles', where='1=1') self.a = article.Article() self.a.url = test_url1 self.a.title = 'Test title' self.a.description = 'Test description' self.a.save()
def GET(self): i = web.input(id=None) try: DB.update('eventos', where='id=$i.id', user_state='t', vars=locals()) except: print "Error Inesperado /user/updateevent:", sys.exc_info() raise web.seeother('/eventos')
def GET(self): i = web.input(id=None) try: DB.delete('clientes', where="id=" + i.id) except: print "Error Inesperado /deleteclient:", sys.exc_info() raise web.seeother('/listclient')
def GET(self): i = web.input(id=None) #print "****************************** Update Event:", i.id try: DB.update('eventos', where='id=$i.id', admin_state='t', vars=locals()) except: print "Error Inesperado /updateevent:", sys.exc_info() #return updateevent raise web.seeother('/managevents')
def set_record(self): try: high_score = DB.store_get('high_score') except KeyError: high_score = 0 if high_score < self.score: DB.store_put('high_score', self.score) DB.store_sync()
def on_dismiss(self, *args): for val in self.score_board: if 'new' in val: text = self.editable_text.text.strip() val['name'] = text and text or DEF_USER val.pop('new') DB.store_put('%sx%s-%s' % (self.board_h, self.board_v, self.level), self.score_board) DB.store_sync() super(CustomPopup, self).on_dismiss(*args)
def update_session(session_id): '''Increments the evaluation pair for a session''' result = DB.select(SESSION_DB_NAME, where='session_id=%d' % session_id, \ what='num_eval') num_eval = result[0]['num_eval'] + 1 DB.update(SESSION_DB_NAME, where='session_id=%d' % session_id, num_eval=num_eval) return num_eval
def setUp(self): DB.delete('user_articles', where='1=1') DB.delete('user_sources', where='1=1') DB.delete('sources', where='1=1') DB.delete('users', where='1=1') DB.insert('users', id=user_id, name='Guest') self.s = source.Source(type='feed', url=test_url1) self.us = source.UserSource(user_id=user_id, source_id=self.s.id)
def save(model): for item in model: DB.insert( 'galleries', name=item['name'], num_collections=item['num_collections'], num_images=item['num_images'], cover_thumb=item['cover_thumb'], last_update=item['last_update'] )
def change_sound(self, *args): global SOUND button = args[0] SOUND = not SOUND button.image.source = 'assets/images/sound_%s.png' % ( SOUND and 'on' or 'off') DB.store_put('sound', SOUND) DB.store_sync() if not SOUND: self.sound.stop()
def set_theme(self, theme=None, *args): if not theme: theme = DB.store_get('theme') self.theme = theme self.background = THEME.get(theme).get('background') self.labels = THEME.get(theme).get('labels') self.free_place_notifier = THEME[self.theme]['labels'] self.change_board_color(self.labels) Window.clearcolor = self.background DB.store_put('theme', theme) DB.store_sync()
def setUp(self): DB.delete('user_opml', where='1=1') DB.delete('user_articles', where='1=1') DB.delete('user_sources', where='1=1') DB.delete('users', where='1=1') self.a = article.Article() self.a.url = test_url1 self.a.title = 'Test title' self.a.description = 'Test description' self.a.save() DB.insert('users', id=user_id, name='Guest')
class Role(DB.Model): __tablename__ = 'role' id = DB.Column(DB.Integer, primary_key=True) # Attributes name = DB.Column(DB.String(30), unique=True, nullable=False) # Relationships: 1 .. n users = DB.relationship('User', back_populates='role') def get_id(self): return self.id
class CoffeeType(DB.Model): __tablename__ = 'coffeetype' id = DB.Column(DB.Integer, primary_key=True) # Attributes name = DB.Column(DB.String(30), unique=True, nullable=False) # Relationships: 1 .. n products = DB.relationship('CoffeeProduct', back_populates='coffee_type') def get_id(self): return self.id
def get_videos(session_id, pair_number): '''Gets the pair id for the round of the given user (session id)''' result = DB.select(SESSION_DB_NAME, where='session_id=%d' % session_id, what='round_rbn') round_num = result[0]['round_rbn'] result = DB.select(PAIRS_DB_NAME, where='pair_num=%d AND round_rbn=%d' % (pair_number, round_num), what='video_id1,video_id2') row = result[0] return row['video_id1'], row['video_id2']
def add_id(session_id): '''Adds new id to the session database''' round_select = DB.select(ROUND_ROBIN_DB_NAME)[0] curr_round = round_select['current_round'] total_rounds = round_select['total_rounds'] DB.insert(SESSION_DB_NAME, session_id=session_id, round_rbn=curr_round, num_eval=0) next_round = (curr_round + 1) % total_rounds return DB.update(ROUND_ROBIN_DB_NAME, where='current_round=%d' % curr_round, current_round=next_round)
def refine_battle_log(): refined_logs = set() count = 0 logs = DB.find('battle_log', {}, {'_id': 0}) for l in logs: refined_logs.add(json.dumps(l)) count += 1 print(count, end=", ") print("Dumping to db") for battle in refined_logs: DB.insert('refined_battle_log', json.loads(battle)) count -= 1 print(count, end=', ')
def num_pairs(session_id): ''' Simply counts the number of rows in the pairs for the round of the given user. ''' result = DB.select(SESSION_DB_NAME, where='session_id=%d' % session_id, what='round_rbn') round_num = result[0]['round_rbn'] count = 0 for _ in DB.select(PAIRS_DB_NAME, where='round_rbn=%d' % round_num): count += 1 return count
def delete_server(self, *args): name = self.input_box.name_input.text.strip() url = self.input_box.url_input.text.strip() repo = self.input_box.repo_input.text.strip() cmd = self.input_box.cmd_input.text.strip() tmp = {'name': name, 'url': url, 'cmd': cmd, 'repo': repo} servers = DB.store_get('servers') if filter(lambda x: x == tmp, servers): servers.pop(servers.index(tmp)) DB.store_put('servers', servers) DB.store_sync() root = findparent(self, Deployment) root.load_servers() root.servers_correction_screenbased('settings')
def POST(self): from appForm import formClient f = formClient() if f.validates(): try: telefonos = {'fijo':f.d.fijo, 'celular':f.d.celular, 'pbx':f.d.pbx, 'fax':f.d.fax} try: nombres = f.d.nombres.split(' ') apellidos = f.d.apellidos.split(' ') nombres.append('') apellidos.append('') except: print "Error Inesperado1 /addclient:", sys.exc_info() return renderbase_admin.addclient(web.ctx.session, f, msgerr='Los Nombre o Apellidos no son validos.') sequence_id = DB.insert('clientes', documento=f.d.documento, tipo_docu=f.d.tipo_docu, fecha_naci=f.d.fecha_naci, direccion=f.d.direccion.lower(), ciudad=f.d.ciudad, sexo_id=f.d.sexo_id, email=f.d.email.lower(), nombre1=nombres[0].lower(), nombre2=nombres[1].lower() or None, apellido1=apellidos[0].lower(), apellido2=apellidos[1].lower() or None) from db import insertPhone insertPhone(telefonos, client_id=sequence_id) except: print "Error Inesperado2 /addclient:", sys.exc_info() return renderbase_admin.addclient(web.ctx.session, f, msgerr='El Cliente: %s %s, ya existe' % (f.d.nombres, f.d.apellidos)) return renderbase_admin.addclient(web.ctx.session, f, u'El Cliente: %s %s, se ha creado con éxito!' % (f.d.nombres, f.d.apellidos)) else: return renderbase_admin.addclient(web.ctx.session, f, msgerr=u'Los datos no son válidos.')
def POST(self, name): user = web.input('user')['user'] desc = web.input(desc=None)['desc'] machine = load_machine(name) if machine.locked: raise web.Forbidden() if machine.type == 'vps': curkey = machine.sshpubkey else: curkey, getstatus = get_sshkey(name) if getstatus != 0: curkey = machine.sshpubkey if machine.sshpubkey != curkey: newkey = curkey else: newkey = machine.sshpubkey res = DB.update('machine', where='name = $name AND locked = false', vars=dict(name=name), locked=True, description=desc, sshpubkey=newkey, locked_by=user, locked_since=web.db.SQLLiteral('NOW()')) assert res == 1, 'Failed to lock machine {name}'.format(name=name) print user, 'locked single machine', name, 'desc', desc
def save_user_info(session_id, age, gender, country, view, share, share_all): '''Saves user demographic data to the database''' return DB.insert(USER_DB_NAME, session_id=session_id, age=age, gender=gender, country=country, watch_videos=view, share_videos=share, share_content=share_all, dateof=datetime.utcnow())
def load_machine(name): results = list(DB.select('machine', what='*', where='name = $name', vars=dict(name=name))) if not results: raise web.NotFound() return results[0]
def get_curr_pair(session_id): '''Gets the current pair being evaluated''' result = DB.select(SESSION_DB_NAME, where='session_id=%d' % session_id, what='curr_pair') return result[0]['curr_pair']
def get_number_evaluated(session_id): '''Get's number of pairs evaluted for a given session''' result = DB.select(SESSION_DB_NAME, where='session_id=%d' % session_id, \ what='num_eval') return result[0]['num_eval']
def check_and_create_device(self, info, addr) -> Optional[Device]: device_info = super().check_and_create_device(info, addr) if device_info is not None: dev = DBDevice.new_from_device_info(info.name, device_info) dev.enabled = True DB.connect() db_dev = DBDevice.find(DB.session, dev.identifier) if db_dev is None: DB.session.add(dev) elif db_dev.address != dev.address: db_dev.address = dev.address DB.close() return device_info
def update_sshkey(name, key, type): if type == 'vps': return res = DB.update('machine', where='name = $name AND locked = false', vars=dict(name=name), sshpubkey=key,) assert res == 1, 'Failed to update key of machine {name}'.format(name=name) print 'Updated key on ', name
def GET(self): rows = list(DB.select('machine', what='*')) if not rows: raise web.NotFound() for row in rows: row.locked_since = row.locked_since.isoformat() web.header('Content-type', 'text/json') return json.dumps(rows)
def save_choice(session_id, pair_id, id1, id2, like, share, pop, know, additional): '''Saves an evaluation''' return DB.insert(EVAL_DB_NAME, session_id=session_id, pair_num=pair_id, video_id1=id1, video_id2=id2, like_choice=like, share_choice=share, pop_choice=pop, additional=additional, know=know, dateof=datetime.utcnow())
def PUT(self, name): desc = web.input(desc=None)['desc'] status = web.input(status=None)['status'] sshpubkey = web.input(sshpubkey=None)['sshpubkey'] updated = {} if desc is not None: updated['description'] = desc if status is not None: updated['up'] = (status == 'up') if sshpubkey is not None: updated['sshpubkey'] = sshpubkey if not updated: raise web.BadRequest() DB.update('machine', where='name = $name', vars=dict(name=name), **updated)
def index(char_id, suffix): try: if char_id: res_by_id = DB.get_by_id(int(char_id)) if suffix in SUFFIXES and res_by_id: return res_by_id[suffix], 200 elif suffix: return "Not implemented", 501 if res_by_id: return json.loads(JSONEncoder().encode(res_by_id)), 200 return "Character not found", 200 res = DB.get_all() if res: return JSONEncoder().encode(res), 200 return "No characters found" except Exception as err: raise Exception(err) return "Internal server error", 500
def add_server(self, *args): name = self.input_box.name_input.text.strip() url = self.input_box.url_input.text.strip() repo = self.input_box.repo_input.text.strip() cmd = self.input_box.cmd_input.text.strip() if name and url and cmd and repo: servers = DB.store_get('servers') servers.append({ 'name': name, 'url': url, 'cmd': cmd, 'repo': repo }) DB.store_put('servers', servers) DB.store_sync() root = findparent(self, Deployment) root.load_servers() root.servers_correction_screenbased('settings')
def has_user_id(session_id): '''Checks if the user demographic database already has this session id''' try: result = DB.select(USER_DB_NAME, where='session_id=%d' % session_id, \ what='session_id') result[0]['session_id'] return True except IndexError: return False
def save_results(session_id, like, share, pop, know, details): '''Saves results and increments video pair number''' with DB.transaction(): pair_number = db.get_curr_pair(session_id) id1, id2 = db.get_videos(session_id, pair_number) db.save_choice(session_id, pair_number, id1, id2, like, share, pop, know, details) return db.update_session(session_id)
def POST(self): from appForm import formGps f = formGps() if f.validates(): try: sequence_id = DB.insert('gps', **f.d) except: return renderbase_admin.addgps(web.ctx.session, f, msgerr='El dispositivo %s ya existe' % f.d.name) return renderbase_admin.addgps(web.ctx.session, f, u'El dispositivo %s, se ha guardado con éxito!' % f.d.name) else: return renderbase_admin.addgps(web.ctx.session, f, msgerr=u'Los datos no son válidos.')
def update_sshkey(name, key, type): if type == 'vps': return res = DB.update( 'machine', where='name = $name AND locked = false', vars=dict(name=name), sshpubkey=key, ) assert res == 1, 'Failed to update key of machine {name}'.format(name=name) print 'Updated key on ', name
def insert_data(data: list, errors: list, report_params: dict): conn_string = f'host={DB.get("host")} dbname= {DB.get("dbname")} user={DB.get("user")} password= {DB.get("password")}' with psycopg2.connect(conn_string) as conn: with conn.cursor() as cursor: if data: template = ','.join(['%s'] * len(data)) insert_query = 'INSERT INTO {table} ("user", ts, context, ip) VALUES {template}'.format( table=DB.get('report_table'), template=template) cursor.execute(insert_query, data) if errors: errors = [(report_params.get('api_report'), report_params.get('api_date'), *err_item, datetime.now()) for err_item in errors] template = ','.join(['%s'] * len(errors)) insert_query = 'INSERT INTO {table} (api_report, api_date, row_text, error_text, ins_ts) VALUES {template}'.format( table=DB.get('error_table'), template=template) cursor.execute(insert_query, errors)
def POST(self): from appForm import formAssignclient f = formAssignclient() if f.validates(): try: sequence_id = DB.insert('clientes_vehiculos', **f.d) except: return renderbase_admin.assignclient(web.ctx.session, f, msgerr=u'No se pudo crear la relación vehículo(%s) a cliente(%s). Porque ya existe!' % (f.d.vehiculo_id, f.d.cliente_id)) return renderbase_admin.assignclient(web.ctx.session, f, u'La relación vehículo(%s) a cliente(%s), se ha guardado con éxito!' % (f.d.vehiculo_id, f.d.cliente_id)) else: return renderbase_admin.assignclient(web.ctx.session, f, msgerr=u'Los datos no son válidos.')
def POST(self, name): user = web.input('user')['user'] machine = load_machine(name) if machine.locked: raise web.Forbidden() res = DB.update('machine', where='name = $name AND locked = false', vars=dict(name=name), locked=True, locked_by=user, locked_since=web.db.SQLLiteral('NOW()')) assert res == 1, 'Failed to lock machine {name}'.format(name=name)
class CoffeeProduct(DB.Model): __tablename__ = 'coffeeproduct' id = DB.Column(DB.Integer, primary_key=True) # Attributes name = DB.Column(DB.String(50), nullable=False) # Foreign Keys coffee_type_id_fk = DB.Column(DB.Integer, DB.ForeignKey('coffeetype.id', name='fk_coffeeproduct_coffee_type')) coffee_brand_id_fk = DB.Column(DB.Integer, DB.ForeignKey('coffeebrand.id', name='fk_coffeeproduct_coffee_brand')) # Relationships: 1 .. n jobs = DB.relationship('Job', back_populates='coffee_product') # Relationships: n .. 1 coffee_type = DB.relationship('CoffeeType', foreign_keys=[coffee_type_id_fk], back_populates='products') coffee_brand = DB.relationship('CoffeeBrand', foreign_keys=[coffee_brand_id_fk], back_populates='products') def get_id(self): return self.id
def load_servers(self): server_datas = DB.store_get('servers') self.servers = [] for server in server_datas: self.servers.append({ 'name': server.get('name', ''), 'url': server.get('url', ''), 'cmd': server.get('cmd', ''), 'repo': server.get('repo', '') }) self.servers.append({'name': '', 'url': '', 'cmd': '', 'repo': ''})
def POST(self): from appForm import formUser f = formUser() if f.validates(): try: sequence_id = DB.insert('usuarios', usuario=f.d.usuario, passwd=f.d.passwd, privilege_id=f.d.privilege_id, activo=f.d.activo, cliente_id=f.d.cliente_id) except: return renderbase_admin.adduser(web.ctx.session, f, msgerr='El usuario %s ya existe' % f.d.usuario) return renderbase_admin.adduser(web.ctx.session, f, u'El usuario %s, se ha creado con éxito!' % f.d.usuario) else: return renderbase_admin.adduser(web.ctx.session, f, msgerr=u'Los datos no son válidos.')
def deploy(self): if self.current == "deploy_screen": self.reset_screen() screen = self.current_screen if not self.branch: self.display_message(screen, u"'branch' is empty!")() self.display_error_buts_deployment() else: if not self.checked_servers: self.display_message( screen, u"at least check one server please!")() self.display_error_buts_deployment() else: requests = [] for server in self.checked_servers: name = server.input_box.name_input.text.strip() url = server.input_box.url_input.text.strip() cmd = server.input_box.cmd_input.text.strip() server_datas = DB.store_get('servers') repo = filter(lambda x: x['name'] == name, server_datas)[0].get('repo') tmp = [ self.display_message( screen, '%s authentication check' % name), self.authentication_check(name, url), self.display_message( screen, '%s branch check' % self.branch), self.branch_check(name, self.branch, repo), self.display_message(screen, '%s command check' % cmd), self.command_check(url, cmd) ] requests.extend(tmp) for server in self.checked_servers: name = server.input_box.name_input.text.strip() url = server.input_box.url_input.text.strip() cmd = server.input_box.cmd_input.text.strip() repo = filter(lambda x: x['name'] == name, server_datas)[0].get('repo') requests.append( self.display_message(screen, '%s deployment...' % name)) tmp_call = self.deploy_server(self.username, self.password, name, url, cmd, self.branch) requests.append(tmp_call) requests.append( self.display_message( screen, "Deployment complete for branch; '%s'" % self.branch)) self.reset_progess()(len(requests)) self.deploymentComplition(requests, output=True)
def DELETE(self, name): user = web.input('user')['user'] machine = load_machine(name) if not machine.locked: raise web.BadRequest() if machine.locked_by != user: raise web.Forbidden() res = DB.update('machine', where='locked = true AND name = $name AND locked_by = $user', vars=dict(name=name, user=user), locked=False, locked_by=None) assert res == 1, 'Failed to unlock machine {name}'.format(name=name)