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)