async def add_team(tables):
async with Connection() as conn:
await conn.execute(Parser.team.insert().values(
name="Chelsea",
created_on='2019-11-07T14:13:44.041152',
site_name="bwin",
link_id=1))
async def create_tables():
async with Connection() as conn:
await conn.execute(CreateTable(SSO.user))
await conn.execute(CreateTable(SSO.group))
await conn.execute(CreateTable(SSO.session))
await conn.execute(CreateTable(SSO.permission))
await conn.execute(CreateTable(SSO.group_permission))
await conn.execute(CreateTable(SSO.user_group))
await conn.execute(SSO.group.insert().values(group_id=1,
name="admins"))
await conn.execute(SSO.group.insert().values(group_id=2,
name="viewers"))
await conn.execute(SSO.group.insert().values(group_id=3,
name="editors"))
await conn.execute(SSO.permission.insert().values(permission_id=1,
name="special"))
await conn.execute(SSO.permission.insert().values(permission_id=2,
name="view"))
await conn.execute(SSO.permission.insert().values(permission_id=3,
name="edit"))
await conn.execute(SSO.group_permission.insert().values(
permission_id=1, group_id=1))
await conn.execute(SSO.group_permission.insert().values(
permission_id=1, group_id=2))
await conn.execute(SSO.group_permission.insert().values(
permission_id=1, group_id=3))
await conn.execute(SSO.group_permission.insert().values(
permission_id=2, group_id=2))
await conn.execute(SSO.group_permission.insert().values(
permission_id=2, group_id=3))
async def create_tables():
async with Connection() as conn:
await conn.execute(
"CREATE TYPE status_team AS ENUM ('New', 'Moderated', 'Approved');"
)
await conn.execute(CreateTable(tb_link))
await conn.execute(CreateTable(tb_real_team))
await conn.execute(CreateTable(tb_team))
await conn.execute(tb_link.insert().values(
site_name="bwin",
link="https://sports.bwin.com/en/sports",
created_on='2019-11-07T14:13:44.041152',
attributes={
"elem": "a",
"class": "js-mg-tooltip"
},
type="team"))
await conn.execute(tb_link.insert().values(
site_name="UEFA",
link="https://en.competitions.uefa.com/"
"memberassociations/uefarankings/club"
"/libraries//years/2020/",
created_on='2019-11-07T14:13:44.041152',
attributes={
"elem": "a",
"class": "team-name visible-md visible-lg"
},
type="real_team"))
async def test_close_connection():
await Engine.init()
await Engine.close()
try:
async with Connection():
assert False
except RuntimeError:
assert True
async def sign_in(request):
try:
data = SigninSchema().load(request.form)
except ValidationError as e:
abort(400, message=e)
else:
async with Connection() as conn:
return await do_sign_in(conn, data)
async def update_and_get_session(user_id):
async with Connection() as conn:
await conn.execute(SSOModels.session.delete().where(
SSOModels.session.c.user_id == user_id))
session_id = str(uuid.uuid4())
await conn.execute(SSOModels.session.insert().values(
session_id=session_id, user_id=user_id))
return session_id
async def create_or_update_real_team(data):
async with Connection() as conn:
try:
await conn.execute(tb_real_team.insert().values(**data))
except psycopg2.IntegrityError:
await conn.execute(tb_real_team.update().where(
tb_real_team.c.name == data["name"]).values(
created_on=datetime.utcnow()))
async def drop_tables():
async with Connection() as conn:
await conn.execute(DropTable(SSOModels.group_permission))
await conn.execute(DropTable(SSOModels.user_group))
await conn.execute(DropTable(SSOModels.user))
await conn.execute(DropTable(SSOModels.group))
await conn.execute(DropTable(SSOModels.session))
await conn.execute(DropTable(SSOModels.permission))
async def add_team_with_moderated_status(tables):
async with Connection() as conn:
await conn.execute(tb_team.insert().values(
team_id="d2c0778d-14b3-c6b1-5a72-232c9b64b680",
name="Chelsea",
created_on='2019-11-07T14:13:44.041152',
site_name="bwin",
link_id=1,
status="Moderated"))
async def sign_up(request):
try:
data = SignupSchema().load(request.form)
except ValidationError as e:
abort(400, message=e)
except PasswordMatchError as e:
abort(423, message=e)
else:
async with Connection() as conn:
return await do_sign_up(conn, data)
async def reset_password(request):
try:
data = ResetPasswordSchema().load(request.form)
except ValidationError as e:
abort(400, message=e)
except PasswordMatchError as e:
abort(423, message=e)
else:
async with Connection() as conn:
return await do_reset_password(conn, data)
async def link_exists(link_id):
flag = False
async with Connection() as conn:
select_link = await conn.execute(
tb_link.select().where(tb_link.c.link_id == link_id))
if select_link.rowcount:
flag = True
return flag
async def get_user_permissions(request):
async with Connection() as conn:
join = join_user_permission()
# Return a new select() construct with the given FROM expression merged into its list of FROM object.
select_permissions = await conn.execute(
select([SSOModels.permission.c.name]).select_from(join).where(
SSOModels.user.c.user_id == request["user_id"]))
permissions = []
async for perm in select_permissions:
permissions.append(perm.name)
return permissions
async def real_team_exists(real_team_id):
flag = False
async with Connection() as conn:
select_real_team = await conn.execute(tb_real_team.select().where(
tb_real_team.c.real_team_id == real_team_id))
if select_real_team.rowcount:
flag = True
return flag
async def check_request_for_authorization_status(request):
async with Connection() as conn:
session = request.cookies.get('session')
flag = False
if session:
result = await conn.execute(SSOModels.session.select().where(
SSOModels.session.c.session_id == session))
row = await result.fetchone()
if row:
request["user_id"] = row.user_id
flag = True
return flag
async def check_permission(request, permission):
async with Connection() as conn:
flag = False
join = join_user_permission()
# Return a new select() construct with the given FROM expression merged into its list of FROM object.
permissions = await conn.execute(
select([SSOModels.permission.c.name]).select_from(join).where(
SSOModels.user.c.user_id == request["user_id"]))
async for perm in permissions:
if permission == perm.name:
flag = True
return flag
async def create_tables():
async with Connection() as conn:
await conn.execute(CreateTable(tb_real_team))
await conn.execute(CreateTable(tb_team))
await conn.execute(tb_team.insert().values(
team_id=1,
name="Team A",
created_on=datetime.utcnow(),
site_name="Some site",
real_team_id=None))
await conn.execute(tb_real_team.insert().values(
real_team_id=1, name='Real Team A', created_on=datetime.utcnow()))
async def create_or_update_team(process_definition_id, data):
async with Connection() as conn:
try:
insert_team = await conn.execute(
tb_team.insert().values(**data,
status=StatusTeam.NEW).returning(
tb_team.c.team_id))
team_id = await insert_team.fetchone()
await Camunda.start_process(process_definition_id, str(team_id[0]))
except psycopg2.errors.UniqueViolation:
await conn.execute(
tb_team.update().values(created_on=datetime.utcnow()).where(
and_(tb_team.c.name == data["name"],
tb_team.c.link_id == data["link_id"])))
async def check_group(request, group):
async with Connection() as conn:
flag = False
# Return a Join from this FromClause to another FromClause.
j = SSOModels.user \
.join(SSOModels.user_group, SSOModels.user.c.user_id == SSOModels.user_group.c.user_id) \
.join(SSOModels.group, SSOModels.user_group.c.group_id == SSOModels.group.c.group_id)
# Return a new select() construct with the given FROM expression merged into its list of FROM objects.
groups = await conn.execute(
select([SSOModels.group.c.name]).select_from(j).where(
SSOModels.user.c.user_id == request["user_id"]))
async for g in groups:
if group == g.name:
flag = True
return flag
async def create_tables():
async with Connection() as conn:
await conn.execute(CreateTable(SSOModels.user))
await conn.execute(CreateTable(SSOModels.group))
await conn.execute(CreateTable(SSOModels.session))
await conn.execute(CreateTable(SSOModels.permission))
await conn.execute(CreateTable(SSOModels.group_permission))
await conn.execute(CreateTable(SSOModels.user_group))
await conn.execute(SSOModels.group.insert().values(group_id=1, name="admins"))
await conn.execute(SSOModels.group.insert().values(group_id=2, name="moderators"))
await conn.execute(SSOModels.group.insert().values(group_id=3, name="viewers"))
await conn.execute(SSOModels.permission.insert().values(permission_id=1, name="approve"))
await conn.execute(SSOModels.permission.insert().values(permission_id=2, name="moderate"))
await conn.execute(SSOModels.permission.insert().values(permission_id=3, name="view"))
await conn.execute(SSOModels.group_permission.insert().values(permission_id=1, group_id=1))
await conn.execute(SSOModels.group_permission.insert().values(permission_id=1, group_id=2))
await conn.execute(SSOModels.group_permission.insert().values(permission_id=1, group_id=3))
await conn.execute(SSOModels.group_permission.insert().values(permission_id=2, group_id=2))
await conn.execute(SSOModels.group_permission.insert().values(permission_id=2, group_id=3))
async def create_tables():
async with Connection() as conn:
await conn.execute(CreateTable(Parser.link))
await conn.execute(CreateTable(Parser.real_team))
await conn.execute(CreateTable(Parser.team))
await conn.execute(Parser.link.insert().values(
site_name="bwin",
link="https://sports.bwin.com/en/sports",
created_on=datetime.utcnow(),
attributes={
"elem": "a",
"cls": "js-mg-tooltip"
}))
await conn.execute(Parser.link.insert().values(
site_name="UEFA",
link="https://en.competitions.uefa.com/"
"memberassociations/uefarankings/club/libraries//years/2020/",
created_on=datetime.utcnow(),
attributes={
"elem": "a",
"cls": "team-name visible-md visible-lg"
}))
async def sign_out(request):
async with Connection() as conn:
return await do_sign_out(request, conn)
async def add_real_team(tables):
async with Connection() as conn:
await conn.execute(Parser.real_team.insert().values(
name="Chelsea", created_on='2019-11-07T14:13:44.041152'))
async def test_acquire_connection():
await Engine.init()
async with Connection():
assert True
await Engine.close()
async def drop_tables():
async with Connection() as conn:
await conn.execute(DropTable(Parser.team))
await conn.execute(DropTable(Parser.real_team))
await conn.execute(DropTable(Parser.link))
async def get_data(filter_data):
async with Connection() as conn:
select = await conn.execute(filter_data)
data = await select.fetchone(
) if select.rowcount == 1 else await select.fetchall()
return data
async def add_user(tables):
async with Connection() as conn:
await conn.execute(SSOModels.user.insert().values(username="******", password=bcrypt.hash("test_data")))
async def drop_tables():
async with Connection() as conn:
await conn.execute(DropTable(tb_team))
await conn.execute(DropTable(tb_real_team))
await conn.execute(DropTable(tb_link))
await conn.execute("DROP TYPE status_team;")
async def add_session(add_user):
async with Connection() as conn:
session_id = str(uuid.uuid4())
await conn.execute(SSOModels.session.insert().values(session_id=session_id, user_id=1))
return session_id
async def update_team(team_id, **kwargs):
async with Connection() as conn:
await conn.execute(
tb_team.update().values(**kwargs,
created_on=datetime.utcnow()).where(
tb_team.c.team_id == team_id))
