def get_all_products(user):
args = check_and_get_args(flask.request.args.to_dict())
query = v1_utils.QueryBuilder(_TABLE, args, _T_COLUMNS)
query.add_extra_condition(_TABLE.c.state != 'archived')
if (user.is_not_super_admin() and user.is_not_read_only_user()
and user.is_not_epm()):
_JPT = models.JOIN_PRODUCTS_TEAMS
query = v1_utils.QueryBuilder(
models.PRODUCTS,
args,
_T_COLUMNS,
root_join_table=_JPT,
root_join_condition=sql.and_(
_JPT.c.product_id == _TABLE.c.id, # noqa
_JPT.c.team_id.in_(user.teams_ids))) # noqa
nb_rows = query.get_number_of_rows()
rows = query.execute(fetchall=True)
rows = v1_utils.format_result(rows, _TABLE.name, args['embed'],
_EMBED_MANY)
return flask.jsonify({'products': rows, '_meta': {'count': nb_rows}})
def get_all_jobs(user, topic_id=None):
"""Get all jobs.
If topic_id is not None, then return all the jobs with a topic
pointed by topic_id.
"""
# get the diverse parameters
args = check_and_get_args(flask.request.args.to_dict())
# build the query thanks to the QueryBuilder class
query = v1_utils.QueryBuilder(_TABLE, args, _JOBS_COLUMNS)
# add extra conditions for filtering
# # If not admin nor rh employee then restrict the view to the team
if (user.is_not_super_admin() and user.is_not_read_only_user()
and user.is_not_epm()):
query.add_extra_condition(_TABLE.c.team_id.in_(user.teams_ids))
# # If topic_id not None, then filter by topic_id
if topic_id is not None:
query.add_extra_condition(_TABLE.c.topic_id == topic_id)
# # Get only the non archived jobs
query.add_extra_condition(_TABLE.c.state != 'archived')
nb_rows = query.get_number_of_rows()
rows = query.execute(fetchall=True)
rows = v1_utils.format_result(rows, _TABLE.name, args['embed'],
_EMBED_MANY)
return flask.jsonify({'jobs': rows, '_meta': {'count': nb_rows}})
def get_jobs_events_from_sequence(user, sequence):
"""Get all the jobs events from a given sequence number."""
args = check_and_get_args(flask.request.args.to_dict())
if user.is_not_super_admin():
raise dci_exc.Unauthorized()
query = sql.select([models.JOBS_EVENTS]). \
select_from(models.JOBS_EVENTS.join(models.JOBS,
models.JOBS.c.id == models.JOBS_EVENTS.c.job_id)). \
where(_TABLE.c.id >= sequence)
sort_list = v1_utils.sort_query(args['sort'], _JOBS_EVENTS_COLUMNS,
default='created_at')
query = v1_utils.add_sort_to_query(query, sort_list)
if args.get('limit', None):
query = query.limit(args.get('limit'))
if args.get('offset', None):
query = query.offset(args.get('offset'))
rows = flask.g.db_conn.execute(query).fetchall()
query_nb_rows = sql.select([func.count(models.JOBS_EVENTS.c.id)])
nb_rows = flask.g.db_conn.execute(query_nb_rows).scalar()
return json.jsonify({'jobs_events': rows, '_meta': {'count': nb_rows}})
def get_all_issues(user):
args = check_and_get_args(flask.request.args.to_dict())
query = v1_utils.QueryBuilder(_TABLE, args, _I_COLUMNS)
query.add_extra_condition(_TABLE.c.state != 'archived')
nb_rows = query.get_number_of_rows()
rows = query.execute(fetchall=True)
rows = v1_utils.format_result(rows, _TABLE.name)
return flask.jsonify({'issues': rows, '_meta': {'count': nb_rows}})
def get_topic_by_id(user, topic_id):
args = check_and_get_args(flask.request.args.to_dict())
topic = v1_utils.verify_existence_and_get(topic_id, _TABLE)
if user.is_not_super_admin() and user.is_not_epm() and user.is_not_feeder(
): # noqa
if not user.is_read_only_user():
v1_utils.verify_team_in_topic(user, topic_id)
if 'teams' in args['embed']:
raise dci_exc.Unauthorized()
return base.get_resource_by_id(user, topic, _TABLE, _EMBED_MANY)
def get_all_tests_by_team(user, team_id):
# todo: remove team_id
args = check_and_get_args(flask.request.args.to_dict())
query = v1_utils.QueryBuilder(_TABLE, args, _T_COLUMNS)
query.add_extra_condition(_TABLE.c.state != 'archived')
# get the number of rows for the '_meta' section
nb_rows = query.get_number_of_rows()
rows = query.execute(fetchall=True)
rows = v1_utils.format_result(rows, _TABLE.name)
return flask.jsonify({'tests': rows, '_meta': {'count': nb_rows}})
def get_all_feeders(user):
args = check_and_get_args(flask.request.args.to_dict())
query = v1_utils.QueryBuilder(_TABLE, args, _F_COLUMNS)
if user.is_not_super_admin() and user.is_not_epm():
query.add_extra_condition(_TABLE.c.team_id.in_(user.teams_ids))
query.add_extra_condition(_TABLE.c.state != 'archived')
rows = query.execute(fetchall=True)
rows = v1_utils.format_result(rows, _TABLE.name, args['embed'],
_EMBED_MANY)
return flask.jsonify({'feeders': rows, '_meta': {'count': len(rows)}})
def get_all_components(user, topic_id):
"""Get all components of a topic."""
args = check_and_get_args(flask.request.args.to_dict())
query = v1_utils.QueryBuilder(_TABLE, args, _C_COLUMNS)
query.add_extra_condition(
sql.and_(_TABLE.c.topic_id == topic_id, _TABLE.c.state != 'archived'))
nb_rows = query.get_number_of_rows()
rows = query.execute(fetchall=True)
rows = v1_utils.format_result(rows, _TABLE.name, args['embed'],
_EMBED_MANY)
return flask.jsonify({'components': rows, '_meta': {'count': nb_rows}})
def get_all_users(user):
args = check_and_get_args(flask.request.args.to_dict())
query = v1_utils.QueryBuilder(_TABLE, args, _USERS_COLUMNS, ['password'])
if user.is_not_super_admin() and user.is_not_epm():
query.add_extra_condition(_TABLE.c.team_id.in_(user.teams_ids))
query.add_extra_condition(_TABLE.c.state != 'archived')
# get the number of rows for the '_meta' section
nb_rows = query.get_number_of_rows()
rows = query.execute(fetchall=True)
rows = v1_utils.format_result(rows, _TABLE.name, args['embed'],
_EMBED_MANY)
return flask.jsonify({'users': rows, '_meta': {'count': nb_rows}})
def list_components_files(user, c_id):
component = v1_utils.verify_existence_and_get(c_id, _TABLE)
topic = v1_utils.verify_existence_and_get(component['topic_id'],
models.TOPICS)
export_control.verify_access_to_topic(user, topic)
args = check_and_get_args(flask.request.args.to_dict())
query = v1_utils.QueryBuilder(models.COMPONENTFILES, args, _CF_COLUMNS)
query.add_extra_condition(models.COMPONENTFILES.c.component_id == c_id)
nb_rows = query.get_number_of_rows(models.COMPONENTFILES,
models.COMPONENTFILES.c.component_id == c_id) # noqa
rows = query.execute(fetchall=True)
rows = v1_utils.format_result(rows, models.COMPONENTFILES.name, None, None)
return flask.jsonify({'component_files': rows,
'_meta': {'count': nb_rows}})
def get_all_jobstates(user, job_id):
"""Get all jobstates.
"""
args = check_and_get_args(flask.request.args.to_dict())
job = v1_utils.verify_existence_and_get(job_id, models.JOBS)
if (user.is_not_super_admin() and user.is_not_read_only_user()
and user.is_not_epm()):
if job['team_id'] not in user.teams_ids:
raise dci_exc.Unauthorized()
query = v1_utils.QueryBuilder(_TABLE, args, _JS_COLUMNS)
query.add_extra_condition(_TABLE.c.job_id == job_id)
# get the number of rows for the '_meta' section
nb_rows = query.get_number_of_rows()
rows = query.execute(fetchall=True)
rows = v1_utils.format_result(rows, _TABLE.name, args['embed'],
_EMBED_MANY)
return flask.jsonify({'jobstates': rows, '_meta': {'count': nb_rows}})
def get_all_topics(user):
def _get_user_product_ids():
_JPT = models.JOIN_PRODUCTS_TEAMS
query = v1_utils.QueryBuilder(
models.PRODUCTS,
{},
{},
root_join_table=_JPT,
root_join_condition=sql.and_(
_JPT.c.product_id == models.PRODUCTS.c.id, # noqa
_JPT.c.team_id.in_(user.teams_ids))) # noqa
user_products = query.execute(fetchall=True)
return [up['products_id'] for up in user_products]
args = check_and_get_args(flask.request.args.to_dict())
# if the user is an admin then he can get all the topics
q_get_topics = v1_utils.QueryBuilder(_TABLE, args, _T_COLUMNS)
if (user.is_not_super_admin() and user.is_not_read_only_user()
and user.is_not_epm()):
if 'teams' in args['embed']:
raise dci_exc.DCIException('embed=teams not authorized.',
status_code=401)
# if regular user, retrieve the topics associated to the user's team
# get only topics with export_control==True or with explicit association
# between the user's teams and the topic
product_ids = _get_user_product_ids()
q_get_topics.add_extra_condition(_TABLE.c.product_id.in_(product_ids))
q_get_topics.add_extra_condition(
sql.or_(
_TABLE.c.export_control == True, # noqa
_TABLE.c.id.in_(v1_utils.user_topic_ids(user)))) # noqa
q_get_topics.add_extra_condition(_TABLE.c.state != 'archived')
# get the number of rows for the '_meta' section
nb_rows = q_get_topics.get_number_of_rows()
rows = q_get_topics.execute(fetchall=True)
rows = v1_utils.format_result(rows, _TABLE.name, args['embed'],
_EMBED_MANY)
return flask.jsonify({'topics': rows, '_meta': {'count': nb_rows}})
def get_all_remotecis(user, t_id=None):
args = check_and_get_args(flask.request.args.to_dict())
# build the query thanks to the QueryBuilder class
query = v1_utils.QueryBuilder(_TABLE,
args,
_R_COLUMNS,
ignore_columns=['keys', 'cert_fp'])
if (user.is_not_super_admin() and user.is_not_read_only_user()
and user.is_not_epm()):
query.add_extra_condition(_TABLE.c.team_id.in_(user.teams_ids))
if t_id is not None:
query.add_extra_condition(_TABLE.c.team_id == t_id)
query.add_extra_condition(_TABLE.c.state != 'archived')
rows = query.execute(fetchall=True)
rows = v1_utils.format_result(rows, _TABLE.name, args['embed'],
_EMBED_MANY)
return flask.jsonify({'remotecis': rows, '_meta': {'count': len(rows)}})
def get_users_from_team(user, team_id):
args = check_and_get_args(flask.request.args.to_dict())
_JUTR = models.JOIN_USERS_TEAMS
query = v1_utils.QueryBuilder(
models.USERS,
args,
users._USERS_COLUMNS,
['password', 'team_id'],
root_join_table=_JUTR,
root_join_condition=sql.and_(
_JUTR.c.user_id == models.USERS.c.id, # noqa
_JUTR.c.team_id == team_id)) # noqa
if user.is_not_epm() and user.is_not_in_team(team_id):
raise dci_exc.Unauthorized()
query.add_extra_condition(models.USERS.c.state != 'archived')
rows = query.execute(fetchall=True)
team_users = v1_utils.format_result(rows, models.USERS.name, args['embed'],
users._EMBED_MANY)
return flask.jsonify({'users': team_users, '_meta': {'count': len(rows)}})
def get_resource_by_id(user,
resource,
table,
embed_many=None,
ignore_columns=None,
resource_name=None,
embeds=None,
jsonify=True):
args = check_and_get_args(flask.request.args.to_dict())
if embeds is not None:
# make a copy of the list to avoid side effect
args['embed'] = args['embed'] + list(embeds)
resource_name = resource_name or table.name[0:-1]
resource_id = resource['id']
columns = v1_utils.get_columns_name_with_objects(table)
query = v1_utils.QueryBuilder(table, args, columns, ignore_columns)
if 'state' in resource:
query.add_extra_condition(table.c.state != 'archived')
query.add_extra_condition(table.c.id == resource_id)
rows = query.execute(fetchall=True)
rows = v1_utils.format_result(rows, table.name, args['embed'], embed_many)
if len(rows) < 1:
raise dci_exc.DCINotFound(resource_name, resource_id)
resource = rows[0]
if jsonify is True:
res = flask.jsonify({resource_name: resource})
if 'etag' in resource:
res.headers.add_header('ETag', resource['etag'])
return res
else:
return resource
def get_all_teams_from_product(user, product_id):
product = v1_utils.verify_existence_and_get(product_id, _TABLE)
if user.is_not_super_admin() and user.is_not_epm():
raise dci_exc.Unauthorized()
args = check_and_get_args(flask.request.args.to_dict())
_JPT = models.JOIN_PRODUCTS_TEAMS
query = v1_utils.QueryBuilder(
models.TEAMS,
args,
teams._T_COLUMNS,
root_join_table=_JPT,
root_join_condition=sql.and_(
_JPT.c.product_id == product['id'], # noqa
_JPT.c.team_id == models.TEAMS.c.id)) # noqa
rows = query.execute(fetchall=True)
return flask.jsonify({
'teams': serialize_teams(rows),
'_meta': {
'count': len(rows)
}
})
def get_teams_of_user(user, user_id):
args = check_and_get_args(flask.request.args.to_dict())
_JUTR = models.JOIN_USERS_TEAMS
query = v1_utils.QueryBuilder(
models.TEAMS,
args,
teams._T_COLUMNS,
root_join_table=_JUTR,
root_join_condition=sql.and_(
_JUTR.c.team_id == models.TEAMS.c.id, # noqa
_JUTR.c.user_id == user_id)) # noqa
if user.is_not_super_admin() and user.id != user_id and user.is_not_epm():
raise dci_exc.Unauthorized()
query.add_extra_condition(models.TEAMS.c.state != 'archived')
# get the number of rows for the '_meta' section
nb_rows = query.get_number_of_rows()
rows = query.execute(fetchall=True)
users_teams = v1_utils.format_result(rows, models.TEAMS.name,
args['embed'], teams._EMBED_MANY)
return flask.jsonify({'teams': users_teams, '_meta': {'count': nb_rows}})
