def remove_metadata(self, metadata_elements):
if isinstance(metadata_elements, str):
metadata_elements = delimit_filtervalue(metadata_elements)
for metadata_value in metadata_elements:
self.filter(metadata__has_key=metadata_value).update(
metadata=DELETE('metadata', Value(metadata_value)))
def remove_scopes(self, scope_elements):
if isinstance(scope_elements, str):
scope_elements = delimit_filtervalue(scope_elements)
for scope_value in scope_elements:
print(scope_value)
self.filter(scopes__overlap=[scope_value]).update(scopes=ARRAY_REMOVE('scopes', Value(scope_value)))
def remove_tags(self, tag_elements):
if isinstance(tag_elements, str):
tag_elements = delimit_filtervalue(tag_elements)
for tag_value in tag_elements:
self.filter(tags__overlap=[tag_value]).update(
tags=ARRAY_REMOVE('tags', Value(tag_value)))
def filter_submitter(self, queryset, name, value):
submitters = delimit_filtervalue(value)
try:
return queryset.filter(submitter__in=[int(user) for user in submitters])
except ValueError:
pass
return queryset.filter(submitter__username__in=submitters)
def filter_all_imports(self, queryset, name, value):
imports = delimit_filtervalue(value)
for index in range(0, len(imports)):
entry = imports[index]
if not entry.startswith(r'"'):
entry = r'"' + entry
if not entry.endswith(r'"'):
entry = entry + r'"'
imports[index] = entry
return queryset.filter(imports__contains=imports)
def add_tags(self, tag_elements, update_feedback=None):
if isinstance(tag_elements, str):
tag_elements = delimit_filtervalue(tag_elements)
if not update_feedback:
update_feedback = { 'warnings': [], 'changes': [] }
for tag_value in tag_elements:
if check_lexical_convention(tag_value):
self.exclude(tags__overlap=[tag_value]).update(tags=ARRAY_APPEND('tags', Value(tag_value)))
msg = 'Added Tag: {}'.format(tag_value)
update_feedback['changes'].append(msg)
else:
msg = 'Skipped Invalid Tag: {}'.format(tag_value)
update_feedback['warnings'].append(msg)
return update_feedback
def filter_any_dependency(self, queryset, name, value):
dependencies = delimit_filtervalue(value)
return queryset.filter(dependencies__overlap=dependencies)
def filter_all_metakeys(self, queryset, name, value):
metakeys = delimit_filtervalue(value)
return queryset.filter(metadata__has_keys=metakeys)
def filter_all_scopes(self, queryset, name, value):
scopes = delimit_filtervalue(value)
return queryset.filter(scopes__contains=scopes)
def filter_any_scope(self, queryset, name, value):
scopes = delimit_filtervalue(value)
return queryset.filter(scopes__overlap=scopes)
def filter_all_imports(self, queryset, name, value):
imports = delimit_filtervalue(value)
return queryset.filter(imports__contains=imports)
def filter_source(self, queryset, name, value):
sources = delimit_filtervalue(value)
return queryset.filter(source__in=sources)
def filter_any_tag(self, queryset, name, value):
tags = delimit_filtervalue(value)
return queryset.filter(tags__overlap=tags)
def process_parsed_rules(self, rules, source, category, submitter, owner, status='active',
add_tags=None, add_metadata=None, prepend_name=None, append_name=None):
# Ensure specified source is valid
if not owner.groupmeta.source_required and not source:
pass
elif owner.groupmeta.source_required and not source:
raise IntegrityError('No Source Specified')
elif source not in owner.groupmeta.source_options:
raise IntegrityError('Invalid Source Specified: {}'.format(source))
# Ensure specified category is valid
if not owner.groupmeta.category_required and not category:
pass
elif owner.groupmeta.category_required and not category:
raise IntegrityError('No Category Specified')
elif category not in owner.groupmeta.category_options:
raise IntegrityError('Invalid Category Specified: {}'.format(category))
# Container for results
feedback = {'errors': [],
'warnings': [],
'rule_upload_count': 0,
'rule_collision_count': 0}
# Rules must have a non-anonymous submitter
if not submitter.is_anonymous():
prepend_conflicts = 0
append_conflicts = 0
for rule in rules:
try:
rule_kwargs = generate_kwargs_from_parsed_rule(rule)
rule_kwargs['owner'] = owner
rule_kwargs['submitter'] = submitter
rule_kwargs['source'] = source
rule_kwargs['category'] = category
rule_kwargs['status'] = status
# Pop comments from kwargs so they don't get processed prematurely
comments = rule_kwargs.pop('comments')
# Process Modifications
if add_tags:
if isinstance(add_tags, str):
add_tags = delimit_filtervalue(add_tags)
for tag_value in add_tags:
if check_lexical_convention(tag_value):
if tag_value not in rule_kwargs['tags']:
rule_kwargs['tags'].append(tag_value)
else:
msg = 'Skipped Invalid Tag: {}'.format(tag_value)
if msg not in feedback['warnings']:
feedback['warnings'].append(msg)
if add_metadata:
for metakey, metavalue in add_metadata.items():
if check_lexical_convention(metakey) and \
(metavalue.isdigit() or metavalue in ('true', 'false') or \
(metavalue.startswith('\"') and metavalue.endswith('\"'))):
rule_kwargs['metadata'][metakey] = metavalue
else:
msg = 'Skipped Invalid Metadata: {}'.format(metakey)
if msg not in feedback['warnings']:
feedback['warnings'].append(msg)
if prepend_name:
new_name = prepend_name + rule_kwargs['name']
if check_lexical_convention(new_name):
rule_kwargs['name'] = new_name
else:
prepend_conflicts += 1
if append_name:
new_name = rule_kwargs['name'] + append_name
if check_lexical_convention(new_name):
rule_kwargs['name'] = new_name
else:
append_conflicts += 1
# Check for rules with exact same detection logic
if self.filter(owner=owner, logic_hash=rule_kwargs['logic_hash']).exists():
raise IntegrityError('A rule with the same logic already exists')
new_rule = self.create(**rule_kwargs)
new_rule.save()
# Process extracted comments
process_extracted_comments(new_rule, comments)
feedback['rule_upload_count'] += 1
except IntegrityError:
feedback['rule_collision_count'] += 1
# Check to see if any name manipulation conflicts occurred for feedback
if prepend_conflicts:
msg = 'Unable To Prepend {} Rule Names'.format(prepend_conflicts)
feedback['warnings'].append(msg)
if append_conflicts:
msg = 'Unable To Append {} Rule Names'.format(append_conflicts)
feedback['warnings'].append(msg)
return feedback
def filter_all_dependencies(self, queryset, name, value):
dependencies = delimit_filtervalue(value)
return queryset.filter(dependencies__contains=dependencies)
def filter_all_tags(self, queryset, name, value):
tags = delimit_filtervalue(value)
return queryset.filter(tags__contains=tags)
def filter_identifier(self, queryset, name, value):
identifiers = [
int(ID) for ID in delimit_filtervalue(value) if ID.isdigit()
]
return queryset.filter(pk__in=identifiers)
def filter_without_tag(self, queryset, name, value):
tags = delimit_filtervalue(value)
return queryset.exclude(tags__overlap=tags)
def filter_category(self, queryset, name, value):
categories = delimit_filtervalue(value)
return queryset.filter(category__in=categories)
def filter_any_import(self, queryset, name, value):
imports = delimit_filtervalue(value)
return queryset.filter(imports__overlap=imports)
