async def session_info(request) -> web.Response:
body = await request.json()
session_id = body['sessionId']
async with request.app['db'].acquire() as conn:
try:
session_result = await conn.execute(sessions.select().where(sessions.c.session_id == session_id))
if session_result.rowcount == 0:
return send_not_found_response()
else:
for session in session_result:
session = dict(session)
client_id = session['client_id']
user_result = await conn.execute(users.select().where(users.c.client_id == client_id))
for user in user_result:
user = dict(user)
return web.json_response({
'result': 'success',
'session': transform_session(session, user)
}, status=HTTPStatusCode.OK)
except Exception as e:
logging.error(f'Unexpected Error: {e}')
return send_unexpected_error_response()
async def get_user(username: str) -> Dict:
query = users.select().where(username == users.c.username)
user = await database.fetch_one(query=query)
if user:
return dict(user)
else:
return None
async def get_user_by_email(self, request: web.Request, user_email: str):
async with request.app['db'].acquire() as conn:
result = await conn.execute(
users.select().where(users.c.client_email == user_email))
if result.rowcount == 0:
return None
user = await result.fetchone()
return dict(user)
async def do_handle(self, session_result, conn) -> web.Response:
for session in session_result:
session = dict(session)
client_id = session['client_id']
user_result = await conn.execute(
users.select().where(users.c.client_id == client_id))
for user in user_result:
user = dict(user)
transformed_session = self.session_service.transform_session(
session, user)
return self.router_service.send_success_response(
self.name, transformed_session)
async def get_users():
q = users.select()
return await database.fetch_all(q)
async def get_with_username(username: str) -> database:
query = users.select().where(username == users.c.username)
logger.info(query)
return await database.fetch_one(query=query)
async def get_all() -> database:
query = users.select()
return await database.fetch_all(query=query)
async def get(id: int) -> database:
query = users.select().where(id == users.c.id)
return await database.fetch_one(query=query)
async def get_user_by_username(username: str):
q = users.select().where(users.c.username == username)
return await database.fetch_one(q)
async def get_user_by_email(email: str):
query = users.select().where(email == users.c.email)
return await database.fetch_one(query=query)
def get_user(db: databases.Database, username: str):
q = users.select().where(users.c.username == username)
res = conn.execute(q).fetchone()
print(res)
return res
async def get_user_by_recovery_code(code: str) -> Optional[Mapping]:
query = users.select()
query = query.where(users.c.recovery_code == code)
query = query.where(users.c.recovery_code_lifetime_end > datetime.now())
return await database.fetch_one(query)
async def get_user_by_id(user_id: int) -> Optional[Mapping]:
query = users.select().where(users.c.id == user_id)
return await database.fetch_one(query)
async def get_user_by_username(username: str) -> Optional[Mapping]:
query = users.select().where(users.c.username == username)
return await database.fetch_one(query=query)
async def get_user_by_email(email: str) -> Optional[Mapping]:
query = users.select().where(users.c.email == email)
return await database.fetch_one(query=query)
