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 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)
