async def activate_link(request, link_id):
async with request.app.engine.acquire() as conn:
trans = await conn.begin()
try:
query = await conn.execute(links.select().where(
links.columns['id'] == link_id
))
link_data = await query.fetchone()
endpoint_query = await conn.execute(links.select().where(and_(
links.columns['endpoint'] == link_data.endpoint,
links.columns['id'] != link_id
)))
for link in await endpoint_query.fetchall():
if link.is_active:
await trans.close()
raise DuplicateActiveLinkForbidden
await conn.execute(links.update().where(
links.columns['id'] == link_id
).values(is_active=True))
await trans.commit()
await trans.close()
except AttributeError:
await trans.close()
raise NotFoundException
async def retrieve_links(request, filters):
async with request.app.engine.acquire() as conn:
link_select = links.select()
for filter in filters.items():
link_select = link_select.where(
links.columns[filter[0]] == filter[1])
queryset = await conn.execute(link_select)
data = []
for link in await queryset.fetchall():
link_data = {
'id': link.id,
'owner': link.owner,
'owner_id': link.owner_id,
'endpoint': link.endpoint,
'url': link.url,
'is_active': link.is_active
}
if link.switch_date:
link_data['switch_date'] = {
'Year': link.switch_date.year,
'Month': link.switch_date.month,
'Day': link.switch_date.day
}
data.append(link_data)
return data
async def retrieve_link(request, link_id):
async with request.app.engine.acquire() as conn:
try:
query = await conn.execute(
links.select().where(links.columns['id'] == link_id))
link_data = await query.fetchone()
data = {
'id': link_data.id,
'owner': link_data.owner,
'owner_id': link_data.owner_id,
'endpoint': link_data.endpoint,
'url': link_data.url,
'is_active': link_data.is_active
}
if link_data.switch_date:
data['switch_date'] = {
'Year': link_data.switch_date.year,
'Month': link_data.switch_date.month,
'Day': link_data.switch_date.day
}
return data
except AttributeError:
raise NotFoundException
async def create_link(request, data):
async with request.app.engine.acquire() as conn:
trans = await conn.begin()
query = await conn.execute(links.select().where(
links.columns['endpoint'] == data['endpoint']).where(
links.columns['is_active'] == True))
link_data = await query.fetchone()
if link_data:
await trans.close()
raise DuplicateActiveLinkForbidden
if data['password']:
salt = os.urandom(32)
password = hashlib.pbkdf2_hmac('sha256',
data['password'].encode('utf-8'),
salt, 100000)
else:
password = None
link_object = await conn.execute(links.insert().values(
owner=data['owner'],
owner_id=data['owner_id'],
password=password,
endpoint=data['endpoint'],
url=data['url'],
switch_date=data['switch_date'],
is_active=True))
if password:
await conn.execute(salts.insert().values(
link_id=link_object.lastrowid, salt=salt))
await trans.commit()
await trans.close()
async def update_link(request, link_id, data):
async with request.app.engine.acquire() as conn:
trans = await conn.begin()
link_update = links.update().where(links.columns['id'] == link_id)
query = await conn.execute(
links.select().where(links.columns['id'] == link_id))
link_data = await query.fetchone()
if not link_data:
await trans.close()
raise NotFoundException
if data['password']:
salt = os.urandom(32)
password = hashlib.pbkdf2_hmac('sha256',
data['password'].encode('utf-8'),
salt, 100000)
if link_data.password:
await conn.execute(salts.update().where(
salts.columns['link_id'] == link_id).values(salt=salt))
else:
await conn.execute(salts.insert().values(link_id=link_id,
salt=salt))
await conn.execute(
link_update.values(url=data['url'],
switch_date=data['switch_date'],
password=password))
else:
await conn.execute(
link_update.values(url=data['url'],
switch_date=data['switch_date']))
await trans.commit()
await trans.close()
async def check_password(request, link_id, form):
if not form.validate():
raise FormInvalidException
async with request.app.engine.acquire() as conn:
try:
link_query = await conn.execute(
links.select().where(links.columns['id'] == link_id).where(
links.columns['password'] != None))
link_data = await link_query.fetchone()
salt_query = await conn.execute(
salts.select().where(salts.columns['link_id'] == link_data.id))
salt_data = await salt_query.fetchone()
password = hashlib.pbkdf2_hmac('sha256',
form.password.data.encode('utf-8'),
salt_data.salt, 100000)
if (link_data.password != password):
raise AccessDeniedException
return link_data.url
except AttributeError as error:
print(error)
raise NotFoundException
async def check_update_form(request, link_id):
async with request.app.engine.acquire() as conn:
query = await conn.execute(
links.select().where(links.columns['id'] == link_id))
link_data = await query.fetchone()
if not link_data:
raise NotFoundException
return link_data
async def endpoint_duplicity_check(conn, data):
query = await conn.execute(links.select().where(and_(
links.columns['endpoint'] == data['endpoint'],
links.columns['is_active'].is_(True)
)))
link_data = await query.fetchone()
if link_data:
raise DuplicateActiveLinkForbidden
async def update_link(request, link_id, data):
async with request.app.engine.acquire() as conn:
query = await conn.execute(
links.select().where(links.columns['id'] == link_id))
link_data = await query.fetchone()
if not link_data:
raise NotFoundException
# Only check for duplicity if the endpoint has changed
new_endpoint, old_endpoint = data['endpoint'], link_data['endpoint']
if new_endpoint and (new_endpoint != old_endpoint):
await endpoint_duplicity_check(conn, data)
trans = await conn.begin()
link_update = links.update().where(links.columns['id'] == link_id)
if data['password'] == config('DEFAULT_PASSWORD'):
await conn.execute(
link_update.values(
endpoint=data['endpoint']
if data['endpoint'] else link_data['endpoint'],
url=await url_validation(data['url'], trans)
if data['url'] else link_data['url'],
switch_date=data['switch_date']))
else:
if link_data.password:
await conn.execute(salts.delete().where(
salts.columns['link_id'] == link_data.id))
if data['password']:
salt = os.urandom(32)
password = hashlib.pbkdf2_hmac(
'sha256', data['password'].encode('utf-8'), salt, 100000)
await conn.execute(salts.insert().values(link_id=link_id,
salt=salt))
else:
password = None
await conn.execute(
link_update.values(
endpoint=data['endpoint']
if data['endpoint'] else link_data['endpoint'],
url=await url_validation(data['url'], trans)
if data['url'] else link_data['url'],
switch_date=data['switch_date'],
password=password))
await trans.commit()
await trans.close()
async def redirect_link(request, link_endpoint):
async with request.app.engine.acquire() as conn:
try:
query = await conn.execute(links.select().where(
links.columns['endpoint'] == link_endpoint).where(
links.columns['is_active'] == True))
link_data = await query.fetchone()
if link_data.password is not None:
return '/authorize/{}'.format(link_data.id)
return link_data.url
except AttributeError:
raise NotFoundException
async def deactivate_link(request, link_id):
async with request.app.engine.acquire() as conn:
trans = await conn.begin()
try:
query = await conn.execute(
links.select().where(links.columns['id'] == link_id))
link_data = await query.fetchone()
await conn.execute(links.update().where(
links.columns['id'] == link_data.id).values(is_active=False))
await trans.commit()
await trans.close()
except AttributeError:
await trans.close()
raise NotFoundException
async def reset_password(request, link_id):
async with request.app.engine.acquire() as conn:
trans = await conn.begin()
query = await conn.execute(
links.select().where(links.columns['id'] == link_id).where(
links.columns['password'] != None))
link_data = await query.fetchone()
if not link_data:
await trans.close()
raise NotFoundException
await conn.execute(links.update().where(
links.columns['id'] == link_data.id).values(password=None))
await conn.execute(
salts.delete().where(salts.columns['link_id'] == link_data.id))
await trans.commit()
await trans.close()