* Made reporting IPR consistant across document searches, IPR searches, AD document queues, last calls, and agendas. All these points now report on the document(s) being directly queried, and the documents those transitively replace or obsolete.

* Brought search results against WGs and document titles into consistency with results from searching for individual documents
* Added the IPR count to the link on the documents main page (when not zero)
* Built on Henrik's reimplementation of all_related_*, making the *_related_* functions return DocAlias lists consistently, and added corresponding _relations_ functions to get lists of actual RelatedDocument objects.
* Added getting the DocAlias with the same name to Document
* Added getting related IPR disclosures (as described in the first bullet) to Document
* Simplified ipr/related.py
* Removed the use of DraftLikeDocAlias and IETFWG from ipr/search.py. Retooled the various search functions and templates to use DocAlias and IprDocAlias directly.
* Removed dead code from ipr/search.py
* Removed the special handling of WG 2000 from ipr/search.py

Fixes bug 1071
 - Legacy-Id: 6042

Author: rjsparks

ietf/doc/models.py

@@ -235,51 +235,64 @@ def canonical_name(self):
             return "charter-ietf-%s" % self.chartered_group.acronym
         return name
 
+    def canonical_docalias(self):
+        return self.docalias_set.get(name=self.name)
+
     def display_name(self):
         name = self.canonical_name()
         if name.startswith('rfc'):
             name = name.upper()
         return name
 
-    def related_that(self, relationship):
-        """Return the documents that are source of relationship targeting self."""
+    def relations_that(self, relationship):
         if isinstance(relationship, str):
             relationship = [ relationship ]
         if isinstance(relationship, tuple):
             relationship = list(relationship)
         if not isinstance(relationship, list):
             raise TypeError("Expected a string, tuple or list, received %s" % type(relationship))
-        return Document.objects.filter(relateddocument__target__document=self, relateddocument__relationship__in=relationship)
+        return RelatedDocument.objects.filter(target__document=self, relationship__in=relationship).select_related('source')
 
-    def related_that_doc(self, relationship):
-        """Return the doc aliases that are target of relationship originating from self."""
+    def all_relations_that(self, relationship, related=None):
+        if not related:
+            related = []
+        rels = self.relations_that(relationship)
+        for r in rels:
+            if not r in related:
+                related += [ r ]
+                related = r.source.all_relations_that(relationship, related)
+        return related
+
+    def relations_that_doc(self, relationship):
         if isinstance(relationship, str):
             relationship = [ relationship ]
         if isinstance(relationship, tuple):
             relationship = list(relationship)
         if not isinstance(relationship, list):
             raise TypeError("Expected a string, tuple or list, received %s" % type(relationship))
-        return DocAlias.objects.filter(relateddocument__source=self, relateddocument__relationship__in=relationship)
+        return RelatedDocument.objects.filter(source=self, relationship__in=relationship).select_related('target__document')
 
-    def all_related_that(self, relationship, related=None):
-        if related is None:
+    def all_relations_that_doc(self, relationship, related=None):
+        if not related:
             related = []
-        rel = self.related_that(relationship)
-        for doc in rel:
-            if not doc in related:
-                related += [ doc ]
-                related = doc.document.all_related_that(relationship, related)
+        rels = self.relations_that_doc(relationship)
+        for r in rels:
+            if not r in related:
+                related += [ r ]
+                related = r.target.document.all_relations_that_doc(relationship, related)
         return related
 
+    def related_that(self, relationship):
+        return list(set([x.source.docalias_set.get(name=x.source.name) for x in self.relations_that(relationship)]))
+
+    def all_related_that(self, relationship, related=None):
+        return list(set([x.source.docalias_set.get(name=x.source.name) for x in self.all_relations_that(relationship)]))
+
+    def related_that_doc(self, relationship):
+        return list(set([x.target for x in self.relations_that_doc(relationship)]))
+
     def all_related_that_doc(self, relationship, related=None):
-        if related is None:
-            related = []
-        rel = self.related_that_doc(relationship)
-        for alias in rel:
-            if not alias in related:
-                related += [ alias ]
-                related = alias.document.all_related_that_doc(relationship, related)
-        return related
+        return list(set([x.target for x in self.all_relations_that_doc(relationship)]))
 
     def telechat_date(self, e=None):
         if not e:
@@ -352,7 +365,7 @@ def friendly_state(self):
             elif state.slug == "repl":
                 rs = self.related_that("replaces")
                 if rs:
-                    return mark_safe("Replaced by " + ", ".join("<a href=\"%s\">%s</a>" % (urlreverse('doc_view', kwargs=dict(name=name)), name) for name in rs))
+                    return mark_safe("Replaced by " + ", ".join("<a href=\"%s\">%s</a>" % (urlreverse('doc_view', kwargs=dict(name=alias.document)), alias.document) for alias in rs))
                 else:
                     return "Replaced"
             elif state.slug == "active":
@@ -383,6 +396,10 @@ def ipr(self):
         from ietf.ipr.models import IprDocAlias
         return IprDocAlias.objects.filter(doc_alias__document=self)
 
+    def related_ipr(self):
+        """Returns the IPR disclosures against this document and those documents this document transitively obsoletes or replaces"""
+        from ietf.ipr.models import IprDocAlias
+        return IprDocAlias.objects.filter(doc_alias__in=list(self.docalias_set.all())+self.all_related_that_doc(['obs','replaces']))
 
 
 class RelatedDocHistory(models.Model):

ietf/doc/views_doc.py

@@ -49,6 +49,7 @@
 from ietf.ietfauth.utils import *
 from ietf.doc.views_status_change import RELATION_SLUGS as status_change_relationships
 from ietf.wgcharter.utils import historic_milestones_for_charter
+from ietf.ipr.models import IprDocAlias
 
 def render_document_top(request, doc, tab, name):
     tabs = []
@@ -92,7 +93,7 @@ def document_main(request, name, rev=None):
 
     group = doc.group
     if doc.type_id == 'conflrev':
-        conflictdoc = doc.related_that_doc('conflrev').get().document
+        conflictdoc = doc.related_that_doc('conflrev')[0].document
 
     revisions = []
     for h in doc.history_set.order_by("time", "id"):
@@ -271,11 +272,11 @@ def document_main(request, name, rev=None):
         search_archive = urllib.quote(search_archive, safe="~")
 
         # conflict reviews
-        conflict_reviews = [d.name for d in doc.related_that("conflrev")]
+        conflict_reviews = [d.document.name for d in doc.related_that("conflrev")]
 
         status_change_docs = doc.related_that(status_change_relationships)
-        status_changes = [ rel for rel in status_change_docs  if rel.get_state_slug() in ('appr-sent','appr-pend')]
-        proposed_status_changes = [ rel for rel in status_change_docs  if rel.get_state_slug() in ('needshep','adrev','iesgeval','defer','appr-pr')]
+        status_changes = [ rel.document for rel in status_change_docs  if rel.document.get_state_slug() in ('appr-sent','appr-pend')]
+        proposed_status_changes = [ rel.document for rel in status_change_docs  if rel.document.get_state_slug() in ('needshep','adrev','iesgeval','defer','appr-pr')]
 
         # remaining actions
         actions = []
@@ -338,9 +339,9 @@ def document_main(request, name, rev=None):
                                        replaces=[d.name for d in doc.related_that_doc("replaces")],
                                        replaced_by=[d.name for d in doc.related_that("replaces")],
                                        updates=[prettify_std_name(d.name) for d in doc.related_that_doc("updates")],
-                                       updated_by=[prettify_std_name(d.canonical_name()) for d in doc.related_that("updates")],
+                                       updated_by=[prettify_std_name(d.document.canonical_name()) for d in doc.related_that("updates")],
                                        obsoletes=[prettify_std_name(d.name) for d in doc.related_that_doc("obs")],
-                                       obsoleted_by=[prettify_std_name(d.canonical_name()) for d in doc.related_that("obs")],
+                                       obsoleted_by=[prettify_std_name(d.document.canonical_name()) for d in doc.related_that("obs")],
                                        conflict_reviews=conflict_reviews,
                                        status_changes=status_changes,
                                        proposed_status_changes=proposed_status_changes,

ietf/idrfc/mails.py

@@ -147,7 +147,7 @@ def generate_last_call_announcementREDESIGN(request, doc):
 
     doc.filled_title = textwrap.fill(doc.title, width=70, subsequent_indent=" " * 3)
 
-    iprs, _ = iprs_from_docs(related_docs(DocAlias.objects.get(name=doc.canonical_name()),[]))
+    iprs, _ = iprs_from_docs(related_docs(DocAlias.objects.get(name=doc.canonical_name())))
     if iprs:
         ipr_links = [ urlreverse("ietf.ipr.views.show", kwargs=dict(ipr_id=i.ipr_id)) for i in iprs]
         ipr_links = [ settings.IDTRACKER_BASE_URL+url if not url.startswith("http") else url for url in ipr_links ]

ietf/idrfc/views_search.py

@@ -44,6 +44,7 @@
 from ietf.person.models import *
 from ietf.group.models import *
 from ietf.ipr.models import IprDocAlias
+from ietf.ipr.search import related_docs
 from ietf.idindex.index import active_drafts_index_by_group
 
 class SearchForm(forms.Form):
@@ -133,9 +134,32 @@ def fill_in_search_attributes(docs):
     for d in docs:
         d.iprs = []
 
+# Consider reworking the following block using all_relations_that_doc? That might simplify the final assembly
+# down to the code at "if a not in docs_dict"...
+
+    rel_docs = []
+    rel_id_camefrom = {}
+    for d in docs:
+        if isinstance(d,DocAlias):
+            d = d.document
+        rel_this_doc = d.all_related_that_doc(['replaces','obs']) 
+        for rel in rel_this_doc:
+            rel_id_camefrom.setdefault(rel.document.pk,[]).append(d.pk)
+        rel_docs += [x.document for x in rel_this_doc]
+
     ipr_docaliases = IprDocAlias.objects.filter(doc_alias__document__in=doc_ids).select_related('doc_alias')
     for a in ipr_docaliases:
         docs_dict[a.doc_alias.document_id].iprs.append(a)
+   
+    rel_docs_dict = dict((d.pk, d) for d in rel_docs)
+    rel_doc_ids = rel_docs_dict.keys()
+    
+    rel_ipr_docaliases = IprDocAlias.objects.filter(doc_alias__document__in=rel_doc_ids).select_related('doc_alias')
+    for a in rel_ipr_docaliases:
+        if a.doc_alias.document_id in rel_id_camefrom:
+            for k in rel_id_camefrom[a.doc_alias.document_id]:
+                if a not in docs_dict[k].iprs:
+                    docs_dict[k].iprs.append(a)
 
     # telechat date, can't do this with above query as we need to get TelechatDocEvents out
     seen = set()

ietf/ipr/related.py

@@ -1,137 +1,15 @@
 # Copyright The IETF Trust 2007, All Rights Reserved
 
-from django.conf import settings
-from django.db.models import Q
-from ietf.idtracker.models import InternetDraft, Rfc
-
-inverse = {
-            'updates': 'is_updated_by',
-            'is_updated_by': 'updates',
-            'obsoletes': 'is_obsoleted_by',
-            'is_obsoleted_by': 'obsoletes',
-            'replaces': 'is_replaced_by',
-            'is_replaced_by': 'replaces',            
-            'is_rfc_of': 'is_draft_of',
-            'is_draft_of': 'is_rfc_of',
-        }
-
-display_relation = {
-            'updates':          'that updated',
-            'is_updated_by':    'that was updated by',
-            'obsoletes':        'that obsoleted',
-            'is_obsoleted_by':  'that was obsoleted by',
-            'replaces':         'that replaced',
-            'is_replaced_by':   'that was replaced by',
-            'is_rfc_of':        'which came from',
-            'is_draft_of':      'that was published as',
-        }
-
-def set_related(obj, rel, target):
-    #print obj, rel, target
-    # remember only the first relationship we find.
-    if not hasattr(obj, "related"):
-        obj.related = target
-        obj.relation = display_relation[rel]
-    return obj
-
-def set_relation(first, rel, second):
-    set_related(first, rel, second)
-    set_related(second, inverse[rel], first)
-
-def related_docs(doc, found = []):    
-    """Get a list of document related to the given document.
-    """
-    #print "\nrelated_docs(%s, %s)" % (doc, found) 
-    found.append(doc)
-    if isinstance(doc, Rfc):
-        try:
-            item = InternetDraft.objects.get(rfc_number=doc.rfc_number)
-            if not item in found:
-                set_relation(doc, 'is_rfc_of', item)
-                found = related_docs(item, found)
-        except InternetDraft.DoesNotExist:
-            pass
-        for entry in doc.updated_or_obsoleted_by.all():
-            item = entry.rfc
-            if not item in found:
-                action = inverse[entry.action.lower()]
-                set_relation(doc, action, item)
-                found = related_docs(item, found)
-        for entry in doc.updates_or_obsoletes.all():
-            item = entry.rfc_acted_on
-            if not item in found:
-                action = entry.action.lower()
-                set_relation(doc, action, item)
-                found = related_docs(item, found)
-    if isinstance(doc, InternetDraft):
-        if doc.replaced_by_id:
-            item = doc.replaced_by
-            if not item in found:
-                set_relation(doc, 'is_replaced_by', item)
-                found = related_docs(item, found)
-        for item in doc.replaces_set.all():
-            if not item in found:
-                set_relation(doc, 'replaces', item)
-                found = related_docs(item, found)
-        if doc.rfc_number:
-            item = Rfc.objects.get(rfc_number=doc.rfc_number)
-            if not item in found:
-                set_relation(doc, 'is_draft_of', item)
-                found = related_docs(item, found)
-    return found
-
-def related_docsREDESIGN(alias, _):
-    """Get related document aliases to given alias through depth-first search."""
-    from ietf.doc.models import RelatedDocument
-    from ietf.doc.proxy import DraftLikeDocAlias
-
-    mapping = dict(
-        updates='that updated',
-        obs='that obsoleted',
-        replaces='that replaced',
-        )
-    inverse_mapping = dict(
-        updates='that was updated by',
-        obs='that was obsoleted by',
-        replaces='that was replaced by',
-        )
+def related_docs(alias):
+    results = list(alias.document.docalias_set.all())
 
-    res = [ alias ]
-    remaining = [ alias ]
-    while remaining:
-        a = remaining.pop()
-        related = RelatedDocument.objects.filter(relationship__in=mapping.keys()).filter(Q(source=a.document) | Q(target=a))
-        for r in related:
-            if r.source == a.document:
-                found = DraftLikeDocAlias.objects.filter(pk=r.target_id)
-                inverse = True
-            else:
-                found = DraftLikeDocAlias.objects.filter(document=r.source)
-                inverse = False
-
-            for x in found:
-                if not x in res:
-                    x.related = a
-                    x.relation = (inverse_mapping if inverse else mapping)[r.relationship_id]
-                    res.append(x)
-                    remaining.append(x)
-
-        # there's one more source of relatedness, a draft can have been published
-        aliases = DraftLikeDocAlias.objects.filter(document=a.document).exclude(pk__in=[x.pk for x in res])
-        for oa in aliases:
-            rel = None
-            if a.name.startswith("rfc") and oa.name.startswith("draft"):
-                rel = "that was published as"
-            elif a.name.startswith("draft") and oa.name.startswith("rfc"):
-                rel = "which came from"
-
-            if rel:
-                oa.related = a
-                oa.relation = rel
-                res.append(oa)
-                remaining.append(oa)
-
-    return res
-
-if settings.USE_DB_REDESIGN_PROXY_CLASSES:
-    related_docs = related_docsREDESIGN
+    rels = alias.document.all_relations_that_doc(['replaces','obs'])
+
+    for rel in rels:
+        rel_aliases = list(rel.target.document.docalias_set.all())
+        
+        for x in rel_aliases:
+            x.related = rel
+            x.relation = rel.relationship.revname
+        results += rel_aliases 
+    return list(set(results))