def delete_file_by_id(user, file_id):
file = v1_utils.verify_existence_and_get(file_id, _TABLE)
if not user.is_in_team(file['team_id']):
raise dci_exc.Unauthorized()
values = {'state': 'archived'}
where_clause = _TABLE.c.id == file_id
with flask.g.db_conn.begin():
query = _TABLE.update().where(where_clause).values(**values)
result = flask.g.db_conn.execute(query)
if not result.rowcount:
raise dci_exc.DCIDeleteConflict('File', file_id)
return flask.Response(None, 204, content_type='application/json')
def delete_meta(job_id, meta_id):
"""Delete a meta from a specific job."""
meta_retrieved = v1_utils.verify_existence_and_get(meta_id, _TABLE)
if meta_retrieved['job_id'] != job_id:
raise dci_exc.DCIDeleteConflict(
"Meta '%s' is not associated to job '%s'." % (meta_id, job_id))
query = _TABLE.delete().where(_TABLE.c.id == meta_id)
result = flask.g.db_conn.execute(query)
if not result.rowcount:
raise dci_exc.DCIConflict('Meta deletion conflict', meta_id)
return flask.Response(None, 204, content_type='application/json')
def delete_component_by_id(user, c_id):
# get If-Match header
if not auth.is_admin(user):
raise auth.UNAUTHORIZED
v1_utils.verify_existence_and_get(c_id, _TABLE)
values = {'state': 'archived'}
where_clause = sql.and_(_TABLE.c.id == c_id)
query = _TABLE.update().where(where_clause).values(**values)
result = flask.g.db_conn.execute(query)
if not result.rowcount:
raise dci_exc.DCIDeleteConflict('Component', c_id)
return flask.Response(None, 204, content_type='application/json')
def delete_component_by_id(user, c_id):
component = v1_utils.verify_existence_and_get(c_id, _TABLE)
if str(component['topic_id']) not in v1_utils.user_topic_ids(user):
raise dci_exc.Unauthorized()
values = {'state': 'archived'}
where_clause = sql.and_(
_TABLE.c.id == c_id
)
query = _TABLE.update().where(where_clause).values(**values)
result = flask.g.db_conn.execute(query)
if not result.rowcount:
raise dci_exc.DCIDeleteConflict('Component', c_id)
return flask.Response(None, 204, content_type='application/json')
def delete_configuration_by_id(user, r_id, c_id):
remoteci = v1_utils.verify_existence_and_get(r_id, models.REMOTECIS)
v1_utils.verify_existence_and_get(c_id, _RCONFIGURATIONS)
if not user.is_in_team(remoteci['team_id']):
raise auth.UNAUTHORIZED
with flask.g.db_conn.begin():
values = {'state': 'archived'}
query = _RCONFIGURATIONS.update().where(
_RCONFIGURATIONS.c.id == c_id).values(**values)
result = flask.g.db_conn.execute(query)
if not result.rowcount:
raise dci_exc.DCIDeleteConflict('rconfiguration', c_id)
return flask.Response(None, 204, content_type='application/json')
def delete_role_by_id(user, role_id):
# get If-Match header
if_match_etag = utils.check_and_get_etag(flask.request.headers)
v1_utils.verify_existence_and_get(role_id, _TABLE)
if not auth.is_admin(user):
raise auth.UNAUTHORIZED
values = {'state': 'archived'}
where_clause = sql.and_(_TABLE.c.etag == if_match_etag,
_TABLE.c.id == role_id)
query = _TABLE.update().where(where_clause).values(**values)
result = flask.g.db_conn.execute(query)
if not result.rowcount:
raise dci_exc.DCIDeleteConflict('Role', role_id)
return flask.Response(None, 204, content_type='application/json')
def delete_test_by_id(user, t_id):
v1_utils.verify_existence_and_get(t_id, _TABLE)
with flask.g.db_conn.begin():
values = {'state': 'archived'}
where_clause = _TABLE.c.id == t_id
query = _TABLE.update().where(where_clause).values(**values)
result = flask.g.db_conn.execute(query)
if not result.rowcount:
raise dci_exc.DCIDeleteConflict('Test', t_id)
for model in [models.FILES]:
query = model.update().where(model.c.test_id == t_id).values(
**values)
flask.g.db_conn.execute(query)
return flask.Response(None, 204, content_type='application/json')
def delete_file_by_id(user, file_id):
file = v1_utils.verify_existence_and_get(file_id, _TABLE)
if not (auth.is_admin(user) or auth.is_in_team(user, file['team_id'])):
raise auth.UNAUTHORIZED
values = {'state': 'archived'}
where_clause = _TABLE.c.id == file_id
with flask.g.db_conn.begin():
query = _TABLE.update().where(where_clause).values(**values)
result = flask.g.db_conn.execute(query)
if not result.rowcount:
raise dci_exc.DCIDeleteConflict('File', file_id)
files_events.create_event(file_id, models.FILES_DELETE)
return flask.Response(None, 204, content_type='application/json')
def delete_feeder_by_id(user, f_id):
if_match_etag = utils.check_and_get_etag(flask.request.headers)
feeder = v1_utils.verify_existence_and_get(f_id, _TABLE)
if not user.is_in_team(feeder['team_id']):
raise auth.UNAUTHORIZED
with flask.g.db_conn.begin():
values = {'state': 'archived'}
where_clause = sql.and_(_TABLE.c.etag == if_match_etag,
_TABLE.c.id == f_id)
query = _TABLE.update().where(where_clause).values(**values)
result = flask.g.db_conn.execute(query)
if not result.rowcount:
raise dci_exc.DCIDeleteConflict('Feeder', f_id)
return flask.Response(None, 204, content_type='application/json')
def delete_user_by_id(user, user_id):
# get If-Match header
if_match_etag = utils.check_and_get_etag(flask.request.headers)
_verify_existence_and_get_user(user_id)
if user.is_not_super_admin():
raise dci_exc.Unauthorized()
values = {'state': 'archived'}
where_clause = sql.and_(_TABLE.c.etag == if_match_etag,
_TABLE.c.id == user_id)
query = _TABLE.update().where(where_clause).values(**values)
result = flask.g.db_conn.execute(query)
if not result.rowcount:
raise dci_exc.DCIDeleteConflict('User', user_id)
return flask.Response(None, 204, content_type='application/json')
def delete_topic_by_id(user, topic_id):
if user.is_not_super_admin() and user.is_not_epm():
raise dci_exc.Unauthorized()
topic_id = v1_utils.verify_existence_and_get(topic_id, _TABLE, get_id=True)
with flask.g.db_conn.begin():
values = {'state': 'archived'}
where_clause = sql.and_(_TABLE.c.id == topic_id)
query = _TABLE.update().where(where_clause).values(**values)
result = flask.g.db_conn.execute(query)
if not result.rowcount:
raise dci_exc.DCIDeleteConflict('Topic', topic_id)
query = models.COMPONENTS.update().where(
models.COMPONENTS.c.topic_id == topic_id).values(**values)
flask.g.db_conn.execute(query)
return flask.Response(None, 204, content_type='application/json')
def delete_component_file(user, c_id, f_id):
COMPONENT_FILES = models.COMPONENT_FILES
component = v1_utils.verify_existence_and_get(c_id, _TABLE)
if str(component['topic_id']) not in v1_utils.user_topic_ids(user):
raise dci_exc.Unauthorized()
v1_utils.verify_existence_and_get(f_id, COMPONENT_FILES)
where_clause = COMPONENT_FILES.c.id == f_id
query = COMPONENT_FILES.delete().where(where_clause)
result = flask.g.db_conn.execute(query)
if not result.rowcount:
raise dci_exc.DCIDeleteConflict('Component File', f_id)
store = dci_config.get_store('components')
file_path = files_utils.build_file_path(component['topic_id'], c_id, f_id)
store.delete(file_path)
return flask.Response(None, 204, content_type='application/json')
def delete_component_file(user, c_id, f_id):
if not auth.is_admin(user):
raise auth.UNAUTHORIZED
COMPONENT_FILES = models.COMPONENT_FILES
component = v1_utils.verify_existence_and_get(c_id, _TABLE)
v1_utils.verify_existence_and_get(f_id, COMPONENT_FILES)
where_clause = COMPONENT_FILES.c.id == f_id
query = COMPONENT_FILES.delete().where(where_clause)
result = flask.g.db_conn.execute(query)
if not result.rowcount:
raise dci_exc.DCIDeleteConflict('Component File', f_id)
swift = dci_config.get_store('components')
file_path = swift.build_file_path(component['topic_id'], c_id, f_id)
swift.delete(file_path)
return flask.Response(None, 204, content_type='application/json')
def delete_topic_by_id(user, topic_id):
if not (auth.is_admin(user)):
raise auth.UNAUTHORIZED
topic_id = v1_utils.verify_existence_and_get(topic_id, _TABLE, get_id=True)
with flask.g.db_conn.begin():
values = {'state': 'archived'}
where_clause = sql.and_(_TABLE.c.id == topic_id)
query = _TABLE.update().where(where_clause).values(**values)
result = flask.g.db_conn.execute(query)
if not result.rowcount:
raise dci_exc.DCIDeleteConflict('Topic', topic_id)
for model in [models.COMPONENTS, models.JOBDEFINITIONS]:
query = model.update().where(model.c.topic_id == topic_id).values(
**values)
flask.g.db_conn.execute(query)
return flask.Response(None, 204, content_type='application/json')
def delete_jobdefinition_by_id(user, jd_id):
# get If-Match header
if_match_etag = utils.check_and_get_etag(flask.request.headers)
v1_utils.verify_existence_and_get(jd_id, _TABLE)
with flask.g.db_conn.begin():
values = {'state': 'archived'}
where_clause = sql.and_(_TABLE.c.etag == if_match_etag,
_TABLE.c.id == jd_id)
query = _TABLE.update().where(where_clause).values(**values)
result = flask.g.db_conn.execute(query)
if not result.rowcount:
raise dci_exc.DCIDeleteConflict('Jobdefinition', jd_id)
for model in [models.JOBS]:
query = model.update().where(model.c.jobdefinition_id == jd_id) \
.values(**values)
flask.g.db_conn.execute(query)
return flask.Response(None, 204, content_type='application/json')
def delete_topic_by_id(user, topic_id):
topic = v1_utils.verify_existence_and_get(topic_id, _TABLE)
if not user.is_super_admin() and \
not ((user.is_product_owner() or user.is_feeder()) and
user.product_id == topic['product_id']):
raise auth.UNAUTHORIZED
topic_id = v1_utils.verify_existence_and_get(topic_id, _TABLE, get_id=True)
with flask.g.db_conn.begin():
values = {'state': 'archived'}
where_clause = sql.and_(_TABLE.c.id == topic_id)
query = _TABLE.update().where(where_clause).values(**values)
result = flask.g.db_conn.execute(query)
if not result.rowcount:
raise dci_exc.DCIDeleteConflict('Topic', topic_id)
query = models.COMPONENTS.update().where(
models.COMPONENTS.c.topic_id == topic_id).values(**values)
flask.g.db_conn.execute(query)
return flask.Response(None, 204, content_type='application/json')