Submitter:	Christian Hammond	Reviewers
Branch:	trunk	Groups:	reviewboard
Bugs:		People:
Change Number:	None	Repository:	Review Board SVN

Description:

Cleaned up some of the models by giving all relationship fields explicit related_name fields, rather than using Django's pre-generated defaults. This makes for more natural names and is something we'd want to do before extensions land later on.

This also moves error types and the custom Manager in reviews to their own files.

Testing Done:

All unit tests pass.

Diff revision 1 (Latest)

Files Changed:

/trunk/reviewboard/accounts/views.py: 2 changes [ 1 2 ]
/trunk/reviewboard/contrib/db/db2wiki.py: 2 changes [ 1 2 ]
/trunk/reviewboard/diffviewer/models.py: 6 changes [ 1 2 3 4 5 6 ]
/trunk/reviewboard/diffviewer/templatetags/difftags.py: 2 changes [ 1 2 ]
/trunk/reviewboard/reviews/datagrids.py: 10 changes [ 1 2 3 4 5 6 7 8 9 10 ]
/trunk/reviewboard/reviews/email.py: 1 change [ 1 ]
/trunk/reviewboard/reviews/errors.py: 1 change [ new content ]
/trunk/reviewboard/reviews/forms.py: 4 changes [ 1 2 3 4 ]
/trunk/reviewboard/reviews/managers.py: 1 change [ new content ]
/trunk/reviewboard/reviews/models.py: 31 changes [ 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 ]
/trunk/reviewboard/reviews/views.py: 6 changes [ 1 2 3 4 5 6 ]
/trunk/reviewboard/reviews/management/commands/index.py: 1 change [ 1 ]
/trunk/reviewboard/reviews/templatetags/reviewtags.py: 5 changes [ 1 2 3 4 5 ]
/trunk/reviewboard/scmtools/models.py: 1 change [ 1 ]
/trunk/reviewboard/templates/diffviewer/view_diff.html: 2 changes [ 1 2 ]
/trunk/reviewboard/templates/iphone/dashboard.html: 1 change [ 1 ]
/trunk/reviewboard/templates/reviews/dashboard.html: 1 change [ 1 ]
/trunk/reviewboard/templates/reviews/review_detail.html: 2 changes [ 1 2 ]
/trunk/reviewboard/webapi/json.py: 9 changes [ 1 2 3 4 5 6 7 8 9 ]
/trunk/reviewboard/webapi/tests.py: 13 changes [ 1 2 3 4 5 6 7 8 9 10 11 12 13 ]

Expand changes

                     request.user.password = newpassword
                 request.user.first_name = form.cleaned_data['first_name']
                 request.user.last_name = form.cleaned_data['last_name']
                 request.user.email = form.cleaned_data['email']
-            request.user.group_set = form.cleaned_data['groups']
+            request.user.review_groups = form.cleaned_data['groups']
             request.user.save()
             profile.first_time_setup_done = True
             profile.syntax_highlighting = \
                 form.cleaned_data['syntax_highlighting']
             'redirect_to': redirect_to,
             'first_name': request.user.first_name,
             'last_name': request.user.last_name,
             'email': request.user.email,
             'syntax_highlighting': profile.syntax_highlighting,
-            'groups': [g.id for g in request.user.group_set.all()],
+            'groups': [g.id for g in request.user.review_groups.all()],
         })
     return render_to_response(template_name, RequestContext(request, {
         'form': form,
         'settings': settings,
         'must_configure': must_configure,
     }))

             ('target_groups', [g.name for g in o.target_groups.all()]),
             ('target_people', [u.username for u in o.target_people.all()]),
             ('bugs_closed', o.get_bug_list()),
             ('public', o.public),
             ('status', o.status),
-            ('diff', o.diffset_history.diffset_set.latest().name),
+            ('diff', o.diffset_history.diffsets.latest().name),
             ('reviews', [(review.user.username, get_object_info(review))
-                         for review in o.review_set.all()]),
+                         for review in o.reviews.all()]),
+        ]
     elif isinstance(o, Review):
         info = [
             ('user', o.user.username),
+        ]

     name = models.CharField(_('name'), max_length=256, core=True)
     revision = models.IntegerField(_("revision"), core=True)
     timestamp = models.DateTimeField(_("timestamp"), default=datetime.now)
     history = models.ForeignKey('DiffSetHistory', null=True, core=True,
                                 raw_id_admin=True,
                                 related_name="diffsets",
                                 verbose_name=_("diff set history"))
-    repository = models.ForeignKey(Repository, verbose_name=_("repository"))
+    repository = models.ForeignKey(Repository, related_name="diffsets",
                                    verbose_name=_("repository"))
     diffcompat = models.IntegerField(
         _('differ compatibility version'),
         default=0,
         help_text=_("The diff generator compatibility version to use. "
                     "This can and should be ignored."))
         This will set an initial revision of 1 if this is the first diffset
         in the history, and will set it to on more than the most recent
         diffset otherwise.
         """
         if self.revision == 0 and self.history != None:
-            if self.history.diffset_set.count() == 0:
+            if self.history.diffsets.count() == 0:
                 # Start on revision 1. It's more human-grokable.
                 self.revision = 1
             else:
-                self.revision = self.history.diffset_set.latest().revision + 1
+                self.revision = self.history.diffsets.latest().revision + 1
         super(DiffSet, self).save()
     def __unicode__(self):
         return u"[%s] %s r%s" % (self.id, self.name, self.revision)
     """
     name = models.CharField(_('name'), max_length=256)
     timestamp = models.DateTimeField(_("timestamp"), default=datetime.now)
     def __unicode__(self):
-        return u'Diff Set History (%s revisions)' % (self.diffset_set.count())
+        return u'Diff Set History (%s revisions)' % self.diffsets.count()
     class Admin:
         pass

     """
     Returns a list of revisions in the specified diffset history, indicating
     which of the revisions is already selected, as determined by the current
     diffset pair.
     """
-    for diffset in history.diffset_set.all():
+    for diffset in history.diffsets.all():
         yield {
             'revision': diffset.revision,
             'is_current': current_pair[0] == diffset and
                           current_pair[1] == None
+        }
 @register.filter
 def interdiff_link_list(history, current_pair):
     """
     Returns a list of revisions in the specified diffset history based on
     the passed interdiff pair.
     """
-    for diffset in history.diffset_set.all():
+    for diffset in history.diffsets.all():
         if current_pair[0].revision < diffset.revision:
             path = "%s-%s" % (current_pair[0].revision, diffset.revision)
         else:
             path = "%s-%s" % (diffset.revision, current_pair[0].revision)

     def render_data(self, review_request):
         user = self.datagrid.request.user
         image_url = None
         image_alt = None
-        reviews = review_request.review_set.filter(user=user)
+        reviews = review_request.reviews.filter(user=user)
         if reviews.filter(public=False).count() > 0:
             # Remind about drafts over finished comments
             image_url = self.image_url
             image_alt = _("Comments drafted")
         if not summary:
             summary = '&nbsp;<i>No Summary</i>'
         if review_request.submitter == self.datagrid.request.user:
             try:
-                draft = review_request.reviewrequestdraft_set.get()
+                draft = review_request.draft.get()
                 summary = conditional_escape(draft.summary)
                 return "<span class=\"draftlabel\">[Draft]</span> " + \
                        summary
             except ReviewRequestDraft.DoesNotExist:
                 pass
     """
     def __init__(self, *args, **kwargs):
         Column.__init__(self, *args, **kwargs)
     def render_data(self, obj):
-        return str(obj.reviewrequest_set.filter(public=True,
+        return str(getattr(obj, self.field_name).filter(public=True,
-                                                status='P').count())
+                                                        status='P').count())
 class ReviewCountColumn(Column):
     """
     A datagrid showing a list of submitters.
     """
     username      = Column(_("Username"), link=True, sortable=True)
     fullname      = Column(_("Full Name"), field_name="get_full_name",
                            link=True, expand=True)
-    pending_count = PendingCountColumn(_("Pending Reviews"), shrink=True)
+    pending_count = PendingCountColumn(_("Pending Reviews"),
                                        field_name="directed_review_requests",
                                        shrink=True)
     def __init__(self, request):
         DataGrid.__init__(self, request, User.objects.filter(is_active=True),
                           _("All submitters"))
         self.default_sort = ["username"]
         self.profile_sort_field = 'sort_submitter_columns'
         self.profile_columns_field = 'submitter_columns'
         self.default_columns = [
-            "username", "fullname", "pending_reviews"
+            "username", "fullname", "pending_count"
+        ]
     @staticmethod
     def link_to_object(obj, value):
         return reverse("user", args=[obj.username])
     """
     star          = StarColumn()
     name          = Column(_("Group ID"), link=True, sortable=True)
     displayname   = Column(_("Group Name"), field_name="display_name",
                            link=True, expand=True)
-    pending_count = PendingCountColumn(_("Pending Reviews"), shrink=True)
+    pending_count = PendingCountColumn(_("Pending Reviews"),
                                        field_name="review_requests",
                                        shrink=True)
     def __init__(self, request, title=_("All groups")):
         DataGrid.__init__(self, request, Group.objects.all(), title)
         self.profile_sort_field = 'sort_group_columns'
         self.profile_columns_field = 'group_columns'
         self.default_sort = ["name"]
         self.default_columns = [
-            "star", "name", "displayname", "pending_reviews"
+            "star", "name", "displayname", "pending_count"
+        ]
 class WatchedGroupDataGrid(GroupDataGrid):
     """

     Returns a list of all people who have been involved in a discussion on
     a review request.
     """
     # See the comment in harvest_people_from_review for this list
     # comprehension.
-    return [u for review in review_request.review_set.all()
+    return [u for review in review_request.reviews.all()
               for u in harvest_people_from_review(review)]
 def mail_review_request(user, review_request, changes=None):
     """Send an e-mail representing the supplied review request.

 class InvalidChangeNumberError(Exception):
     def __init__(self):
         Exception.__init__(self, None)
 class ChangeNumberInUseError(Exception):
     def __init__(self, review_request=None):
         Exception.__init__(self, None)
         self.review_request = review_request
 class ChangeSetError(ValueError):
     pass
 class OwnershipError(ValueError):
     pass

 import re
 from django import newforms as forms
 from django.utils.translation import ugettext as _
 from PIL import Image
 from reviewboard.diffviewer.forms import UploadDiffForm, EmptyDiffError
 from reviewboard.reviews.errors import ChangeNumberInUseError, \
                                        ChangeSetError, \
                                        OwnershipError
 from reviewboard.reviews.models import ReviewRequest, \
-                                       ReviewRequestDraft, Screenshot, \
+                                       ReviewRequestDraft, Screenshot
-                                       ChangeNumberInUseError
 from reviewboard.scmtools.models import Repository
-class ChangeSetError(ValueError):
-    pass
-class OwnershipError(ValueError):
-    pass
 class NewReviewRequestForm(forms.Form):
     """
     A form that handles creationg of new review requests. These take
     information on the diffs, the repository the diffs are against, and
     optionally a changelist number (for use in certain repository types

 from django.contrib.auth.models import User
 from django.db.models import Q
 from djblets.util.db import ConcurrencyManager
 from reviewboard.diffviewer.models import DiffSetHistory

Review Board

beta

This change has been marked as submitted.

Clean up several aspects of the models

Diff revision 1 (Latest)