def resolve__related_cases(self, info, args): if not case_cache_enabled(): return [] # Don't resolve related cases for cases if cls.label == "case": return [] q = with_path_to( get_authorized_query(md.Case), { "type": cls.label, "id": self.id }, info, name="related_cases", ) qcls = __gql_object_classes["case"] try: return [ qcls(**load_node(n, info, Node.fields_depend_on_columns)) for n in q.all() ] except Exception as e: capp.logger.exception(e) raise
def resolve_related_cases(self, info, **args): if case_cache_enabled(): return [ instantiate_safely(TransactionResponseEntityRelatedCases, case) for case in self.related_cases ] else: return []
def resolve_related_cases(self, info, **args): if not case_cache_enabled(): return [] related_cases = {} for document in self.documents: entities = document.response_json.get("entities", []) for entity in entities: for related_case in entity.get("related_cases", []): related_cases["id"] = { "id": related_case.get("id", None), "submitter_id": related_case.get("submitter_id", None), } return [ instantiate_safely(TransactionResponseEntityRelatedCases, case) for case in related_cases.values() ]
def with_path_to(q, value, info, union=False, name='with_path_to'): """This will traverse any (any meaning any paths specified in the path generation heuristic which prunes some redundant/wandering paths) from the source entity to the given target type where it will apply a given query. This filter is a logical conjunction (*AND*) over subfilters. """ if not isinstance(value, list): value = [value] union_qs = [] for entry in value: entry = dict(entry) # Check target type dst_type = entry.pop('type', None) if not dst_type: raise RuntimeError( 'Please specify a {{type: <type>}} in the {} filter.'.format( name)) # Prevent traversal to Node interface if q.entity() is Node: raise RuntimeError( '{} filter cannot be used with "node" interface'.format(name)) # Define end of traversal filter def end_of_traversal_filter(q, entry=entry): if not entry: return q for key, val in entry.iteritems(): if key == 'id': q = q.ids(val) else: q = q.filter(q.entity()._props.contains({key: val})) return q # Special case for traversing TO case if case_cache_enabled() and dst_type == 'case': # Rely on shortcut link to case, if it doesn't exist, then # this entity does not relate to any cases if hasattr(q.entity(), '_related_cases'): subq = q.subq_path('_related_cases', end_of_traversal_filter) else: subq = q.filter(sa.sql.false()) # Special case for traversing FROM case elif case_cache_enabled() and q.entity().label == 'case': link = '_related_{}'.format(dst_type) q = q.limit(None) if hasattr(q.entity(), link): subq = q.subq_path(link, end_of_traversal_filter) else: subq = q.filter(sa.sql.false()) # Otherwise do a full traversal else: subq = subq_paths(q, dst_type, end_of_traversal_filter) # Add the subq for this dst_type (multiplex on :param:`union`) if union: union_qs += [subq] else: q = subq # Construct final query (multiplex on :param:`union`) if union and union_qs: # If we are taking a union of the paths (i.e. OR) compile the union q = union_qs.pop(0) for union_q in union_qs: q = q.union(union_q) elif union and not union_qs: q = q.filter(sa.sql.false()) return q
def get_node_class_link_attrs(cls): attrs = { name: graphene.List( __name__ + '.' + link['type'].label, args=get_node_class_args(link['type']), ) for name, link in cls._pg_edges.iteritems() } def resolve__related_cases(self, info, args): if not case_cache_enabled(): return [] # Don't resolve related cases for cases if cls.label == 'case': return [] q = with_path_to(get_authorized_query(md.Case), { 'type': cls.label, 'id': self.id, }, info, name='related_cases') qcls = __gql_object_classes['case'] try: return [ qcls(**load_node(n, info, Node.fields_depend_on_columns)) for n in q.all() ] except Exception as e: capp.logger.exception(e) raise if case_cache_enabled(): attrs['resolve__related_cases'] = resolve__related_cases attrs['_related_cases'] = graphene.List( 'peregrine.resources.submission.graphql.node.case', args=get_node_class_args(md.Case)) for link in cls._pg_edges: name = COUNT_NAME.format(link) attrs[name] = graphene.Field(graphene.Int, args=get_node_class_args(cls)) # transaction logs that affected this node def resolve_transaction_logs_count(self, info, **args): args = dict(args, **{'entities': [self.id]}) return transaction.resolve_transaction_log_count(self, info, **args) attrs['resolve__transaction_logs_count'] = resolve_transaction_logs_count attrs['_transaction_logs_count'] = graphene.Field( graphene.Int, args=transaction.get_transaction_log_args(), ) def resolve_transaction_logs(self, info, **args): args = dict(args, **{'entities': [self.id]}) return transaction.resolve_transaction_log(self, info, **args) attrs['resolve__transaction_logs'] = resolve_transaction_logs attrs['_transaction_logs'] = graphene.List( transaction.TransactionLog, args=transaction.get_transaction_log_args(), ) _links_args = get_node_interface_args() _links_args.pop('of_type', None) attrs['_links'] = graphene.List(Node, args=_links_args) return attrs