async def _resolve_fields(info, project_name):
"""Async resolve fields."""
result = dict(
repositories=list(),
environments=list(),
files=list()
)
tasks = list()
project_name = project_name.lower()
project_exist = project_domain.get_attributes(
project_name, ['project_name']
)
if not project_exist:
raise InvalidProject
for requested_field in info.field_nodes[0].selection_set.selections:
snk_fld = convert_camel_case_to_snake(requested_field.name.value)
if snk_fld.startswith('_'):
continue
resolver_func = getattr(
sys.modules[__name__],
f'_get_{snk_fld}'
)
future = asyncio.ensure_future(resolver_func(project_name))
tasks.append(future)
tasks_result = await asyncio.gather(*tasks)
for dict_result in tasks_result:
result.update(dict_result)
return result
def mutate(self, info, project_name, tags):
success = False
project_name = project_name.lower()
if project_domain.is_alive(project_name):
if project_domain.validate_tags(project_name, tags):
project_tags = project_domain.get_attributes(project_name, ['tag'])
if not project_tags:
project_tags = {'tag': set(tag for tag in tags)}
else:
project_tags.get('tag').update(tags)
tags_added = project_domain.update(project_name, project_tags)
if tags_added:
success = True
else:
rollbar.report_message('Error: \
An error occurred adding tags', 'error', info.context)
else:
util.cloudwatch_log(info.context,
'Security: \
Attempted to upload tags without the allowed structure')
else:
util.cloudwatch_log(info.context,
'Security: \
Attempted to upload tags without the allowed validations')
if success:
util.invalidate_cache(project_name)
ret = AddTags(success=success, project=Project(project_name))
return ret
def resolve_tags(self, info):
""" Resolve project tags """
del info
project_data = project_domain.get_attributes(self.name, ['tag'])
self.tags = project_data['tag'] if project_data and 'tag' in project_data else []
return self.tags
def resolve_total_treatment(self, info):
"""Resolve total treatment attribute."""
del info
total_treatment = project_domain.get_attributes(self.name, ['total_treatment'])
total_treatment_decimal = total_treatment.get('total_treatment', {})
self.total_treatment = json.dumps(
total_treatment_decimal, use_decimal=True)
return self.total_treatment
def resolve_remediated_over_time(self, info):
"Resolve remediated over time"
del info
remediated_over_time = project_domain.get_attributes(self.name, ['remediated_over_time'])
remediate_over_time_decimal = remediated_over_time.get('remediated_over_time', {})
remediated_twelve_weeks = [lst_rem[-12:] for lst_rem in remediate_over_time_decimal]
self.remediated_over_time = json.dumps(
remediated_twelve_weeks, use_decimal=True)
return self.remediated_over_time
def resolve_subscription(self, info):
"""Resolve subscription attribute."""
del info
project_info = project_domain.get_attributes(self.name, ['type'])
if project_info:
self.subscription = project_info.get('type', '')
else:
self.subscription = ''
return self.subscription
def __init__(self, project_name: str):
self.project_name: str = project_name
self.repositories: _List[Dict[str, Any]] = []
self.environments: _List[Dict[str, Any]] = []
self.files: _List[Dict[str, Any]] = []
project_exist = project_domain.get_attributes(project_name.lower(), ['project_name'])
if project_exist:
project_info = project_domain.get_attributes(
project_name.lower(), ['repositories', 'environments', 'files'])
if project_info:
self.repositories = project_info.get('repositories', [])
self.environments = project_info.get('environments', [])
self.files = project_info.get('files', [])
else:
# Project does not have resources
pass
else:
raise InvalidProject
def mutate(self, info, project_name, tag):
success = False
project_name = project_name.lower()
if project_domain.is_alive(project_name):
project_tags = project_domain.get_attributes(project_name, ['tag'])
project_tags.get('tag').remove(tag)
if project_tags.get('tag') == set():
project_tags['tag'] = None
tag_deleted = project_domain.update(project_name, project_tags)
if tag_deleted:
success = True
else:
rollbar.report_message('Error: \
An error occurred removing a tag', 'error', info.context)
if success:
util.invalidate_cache(project_name)
util.cloudwatch_log(info.context, 'Security: Removed tag from \
{project} project succesfully'.format(project=project_name))
else:
util.cloudwatch_log(info.context, 'Security: Attempted to remove \
tag in {project} project'.format(project=project_name))
ret = RemoveTag(success=success, project=Project(project_name))
return ret
def resolve_has_forces(self, info):
"""Resolve if the project has the Forces service."""
del info
attributes = project_domain.get_attributes(self.name, ['has_forces'])
self.has_forces = attributes.get('has_forces', False)
return self.has_forces
def resolve_mean_remediate(self, info):
"""Resolve mean to remediate a vulnerability attribute."""
del info
mean_remediate = project_domain.get_attributes(self.name, ['mean_remediate'])
self.mean_remediate = mean_remediate.get('mean_remediate', 0)
return self.mean_remediate
def resolve_max_open_severity(self, info):
"""Resolve maximum severity in open vulnerability attribute."""
del info
max_open_severity = project_domain.get_attributes(self.name, ['max_open_severity'])
self.max_open_severity = max_open_severity.get('max_open_severity', 0)
return self.max_open_severity
def resolve_last_closing_vuln(self, info):
"""Resolve days since last closing vuln attribute."""
del info
last_closing_vuln = project_domain.get_attributes(self.name, ['last_closing_date'])
self.last_closing_vuln = last_closing_vuln.get('last_closing_date', 0)
return self.last_closing_vuln
def _get_files(project_name: str):
"""Get files."""
project_info = project_domain.get_attributes(
project_name, ['files']
)
return dict(files=project_info.get('files', []))
def _get_environments(project_name: str):
"""Get environments."""
project_info = project_domain.get_attributes(
project_name, ['environments']
)
return dict(environments=project_info.get('environments', []))
def _get_repositories(project_name: str):
"""Get repositories."""
project_info = project_domain.get_attributes(
project_name, ['repositories']
)
return dict(repositories=project_info.get('repositories', []))