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

Description:

We had several utility functions in reviews.db, but these should have gone in a ReviewRequestManager. Added one and ported all the code over.

Testing Done:

Review request creation and updating still works, as does the dashboard, lists, diff view and review request detail page.

Diff revision 1 (Latest)

Files Changed:

/trunk/reviewboard/reviews/db.py: 1 change [ deleted content ]
/trunk/reviewboard/reviews/feeds.py: 4 changes [ 1 2 3 4 ]
/trunk/reviewboard/reviews/forms.py: 6 changes [ 1 2 3 4 5 6 ]
/trunk/reviewboard/reviews/models.py: 4 changes [ 1 2 3 4 ]
/trunk/reviewboard/reviews/templatetags/reviewtags.py: 7 changes [ 1 2 3 4 5 6 7 ]
/trunk/reviewboard/reviews/urls/json.py: 10 changes [ 1 2 3 4 5 6 7 8 9 10 ]

Expand changes

-from django.db.models import Q
-from reviewboard.diffviewer.models import DiffSetHistory
-from reviewboard.reviews.models import ReviewRequest
-def _get_review_request_list(user, status, extra_query=None):
-    query = Q(public=True)
-    if user and user.is_authenticated():
-        query = query | Q(submitter=user)
-    if status:
-        query = query & Q(status=status)
-    if extra_query:
-        query = query & extra_query
-    return ReviewRequest.objects.filter(query).distinct()
-def get_all_review_requests(user=None, status='P'):
-    return _get_review_request_list(user, status)
-def get_review_requests_to_group(group_name, user=None, status='P'):
-    return _get_review_request_list(user, status,
-                                    Q(target_groups__name=group_name))
-def get_review_requests_to_user_groups(username, user=None, status='P'):
-    return _get_review_request_list(user, status,
-                                    Q(target_groups__users__username=username))
-def get_review_requests_to_user_directly(username, user=None, status='P'):
-    return _get_review_request_list(user, status,
-                                    Q(target_people__username=username))
-def get_review_requests_from_user(username, user=None, status='P'):
-    return _get_review_request_list(user, status,
-                                    Q(submitter__username=username))
-def get_review_requests_to_user(username, user=None, status='P'):
-    # Using an OR query inside the extra_query field like this:
-    # Q(target_people__username=username) |
-    #     Q(target_groups__users__username=username))
-    # does not work.  I haven't exactly figured out why.
-    # This is disgusting, but it actually works =P
-    # FIXME: it might be useful to cache this and invalidate the cache every
-    #        time the status on a review request changes.
-    results = []
-    def add_if_unique(requests):
-        for request in requests:
-            found = False
-            for result in results:
-                if request.id == result.id:
-                    found = True
-            if not found:
-                results.append(request)
-    add_if_unique(get_review_requests_to_user_groups(username, user, status))
-    add_if_unique(get_review_requests_to_user_directly(username, user, status))
-    results.sort(lambda a, b: cmp(a.last_updated, b.last_updated),
-                 reverse=True)
-    return results
-def get_review_requests_from_user(username, user=None, status='P'):
-    return _get_review_request_list(user, status,
-                                    Q(submitter__username=username))
-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
-def update_review_request_from_changenum(review_request, changenum):
-    changeset = \
-        review_request.repository.get_scmtool().get_changeset(changenum)
-    if not changeset:
-        raise InvalidChangeNumberError()
-    review_request.changenum = changenum
-    review_request.summary = changeset.summary
-    review_request.description = changeset.description
-    review_request.testing_done = changeset.testing_done
-    review_request.branch = changeset.branch
-    review_request.bugs_closed = ','.join(changeset.bugs_closed)
-def create_review_request(user, repository, changenum=None):
-    try:
-        review_request = ReviewRequest.objects.get(changenum=changenum,
-                                                   repository=repository)
-        raise ChangeNumberInUseError(review_request)
-    except ReviewRequest.DoesNotExist:
-        pass
-    review_request = ReviewRequest(repository=repository)
-    if changenum:
-        update_review_request_from_changenum(review_request, changenum)
-    diffset_history = DiffSetHistory()
-    diffset_history.save()
-    review_request.diffset_history = diffset_history
-    review_request.submitter = user
-    review_request.status = 'P'
-    review_request.public = False
-    review_request.save()
-    return review_request

 from django.contrib.auth.models import User
 from django.contrib.syndication.feeds import Feed
 from django.core.exceptions import ObjectDoesNotExist
 from django.utils.feedgenerator import Atom1Feed
-from reviewboard.reviews.db import get_all_review_requests, \
-                                   get_review_requests_to_user_directly, \
-                                   get_review_requests_to_group
 from reviewboard.reviews.models import Group
 class BaseReviewFeed(Feed):
     title_template = "feeds/reviews_title.html"
     description_template = "feeds/reviews_description.html"
     title = "Review Requests"
     link = "/r/all/"
     description = "All pending review requests."
     def items(self):
-        return get_all_review_requests()[:20]
+        return ReviewRequest.objects.public()[:20]
 class RssSubmitterReviewsFeed(BaseReviewFeed):
     def get_object(self, bits):
         if len(bits) != 1:
     def description(self, submitter):
         return "Pending review requests to %s" % submitter
     def items(self, submitter):
-        return get_review_requests_to_user_directly(submitter.username).\
+        return ReviewRequest.objects.to_user_directly(submitter.username).\
             order_by('-last_updated')[:20]
 class RssGroupReviewsFeed(BaseReviewFeed):
     def get_object(self, bits):
     def description(self, group):
         return "Pending review requests to %s" % group
     def items(self, group):
-        return get_review_requests_to_group(group).\
+        return ReviewRequest.objects.to_group(group).\
             order_by('-last_updated')[:20]
 # Atom feeds
 class AtomReviewsFeed(RssReviewsFeed):
     feed_type = Atom1Feed
 class AtomSubmitterReviewsFeed(RssSubmitterReviewsFeed):
     feed_type = Atom1Feed
 class AtomGroupReviewsFeed(RssGroupReviewsFeed):
     feed_type = Atom1Feed

 import re
 from django import newforms as forms
 from PIL import Image
 from reviewboard.diffviewer.forms import UploadDiffForm, EmptyDiffError
 from reviewboard.reviews.models import ReviewRequest, \
-                                       ReviewRequestDraft, Screenshot
+                                       ReviewRequestDraft, Screenshot, \
-from reviewboard.scmtools.models import Repository
-from reviewboard.reviews.db import create_review_request, \
-                                   update_review_request_from_changenum, \
-                                   ChangeNumberInUseError
+                                       ChangeNumberInUseError
 from reviewboard.scmtools.models import Repository
 class OwnershipError(ValueError):
     pass
             except NotImplementedError:
                 # This scmtool doesn't have changesets
                 pass
         try:
-            review_request = \
+            review_request = ReviewRequest.objects.create(user, repository,
-                create_review_request(user, repository, changenum)
+                                                          changenum)
         except ChangeNumberInUseError:
-            review_request = \
+            review_request = ReviewRequest.objects.get(changenum=changenum)
-                ReviewRequest.objects.get(changenum=changenum)
+            review_request.update_from_changenum(changenum)
             update_review_request_from_changenum(review_request, changenum)
             if review_request.status == 'D':
                 review_request.status = 'P'
                 review_request.public = False
             review_request.save()
         diff_form = UploadDiffForm(repository, data={
             'basedir': self.cleaned_data['basedir'],
         },

 from reviewboard.scmtools.models import Repository
 from reviewboard.utils.fields import ModificationTimestampField
 from utils.templatetags.htmlutils import thumbnail
 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 Group(models.Model):
     name = models.CharField(maxlength=64)
     display_name = models.CharField(maxlength=64)
     mailing_list = models.EmailField(blank=True)
     users = models.ManyToManyField(User, core=False, blank=True,
     class Admin:
         list_display = ('thumb', 'caption', 'image')
         list_display_links = ('thumb', 'caption')
 class ReviewRequestManager(models.Manager):
     """
     A manager for review requests. Provides specialized queries to retrieve
     review requests with specific targets or origins, and to create review
     requests based on certain data.
     """
     def create(self, user, repository, changenum=None):
         """
         Creates a new review request, optionally filling in fields based off
         a change number.
         """
         if changenum:
             try:
                 review_request = self.get(changenum=changenum,
                                           repository=repository)
                 raise ChangeNumberInUseError(review_request)
             except ReviewRequest.DoesNotExist:
                 pass
         review_request = ReviewRequest(repository=repository)
         if changenum:
             review_request.update_from_changenum(changenum)
         diffset_history = DiffSetHistory()
         diffset_history.save()
         review_request.diffset_history = diffset_history
         review_request.submitter = user
         review_request.status = 'P'
         review_request.public = False
         review_request.save()
         return review_request
     def public(self, user=None, status='P'):
         return self._query(user, status)
     def to_group(self, group_name, user=None, status='P'):
         return self._query(user, status, Q(target_groups__name=group_name))
     def to_user_groups(self, username, user=None, status='P'):
         return self._query(user, status,
                            Q(target_groups__users__username=username))
     def to_user_directly(self, username, user=None, status='P'):
         return self._query(user, status, Q(target_people__username=username))
     def to_user(self, username, user=None, status='P'):
         # Using an OR query inside the extra_query field like this:
         # Q(target_people__username=username) |
         #     Q(target_groups__users__username=username))
         # does not work.  I haven't exactly figured out why.
         # This is disgusting, but it actually works =P
         # FIXME: it might be useful to cache this and invalidate the cache every
         #        time the status on a review request changes.
         results = []
         def add_if_unique(requests):
             for request in requests:
                 found = False
                 for result in results:
                     if request.id == result.id:
                         found = True
                 if not found:
                     results.append(request)
         add_if_unique(self.to_user_groups(username, user, status))
         add_if_unique(self.to_user_directly(username, user, status))
         results.sort(lambda a, b: cmp(a.last_updated, b.last_updated),
                      reverse=True)
         return results
     def from_user(self, username, user=None, status='P'):
         return self._query(user, status, Q(submitter__username=username))
     def _query(self, user, status, extra_query=None):
         query = Q(public=True)
         if user and user.is_authenticated():
             query = query | Q(submitter=user)
         if status:
             query = query & Q(status=status)
         if extra_query:
             query = query & extra_query
         return self.filter(query).distinct()
 class ReviewRequest(models.Model):
     STATUSES = (
         ('P', 'Pending Review'),
         ('S', 'Submitted'),
         ('D', 'Discarded'),
                                          related_name="review_request",
                                          core=False, blank=True)
     inactive_screenshots = models.ManyToManyField(Screenshot,
         related_name="inactive_review_request", core=False, blank=True)
     # Set this up with the ReviewRequestManager
     objects = ReviewRequestManager()
     def get_bug_list(self):
         bugs = re.split(r"[, ]+", self.bugs_closed)
         bugs.sort(cmp=lambda x,y: int(x) - int(y))
         return bugs
                     public=True,
                     timestamp__gt=visit.timestamp).exclude(user=user)
         return self.review_set.get_empty_query_set()
     def update_from_changenum(self, changenum):
         changeset = self.repository.get_scmtool().get_changeset(changenum)
         if not changeset:
             raise InvalidChangeNumberError()
         self.changenum = changenum
         self.summary = changeset.summary
         self.description = changeset.description
         self.testing_done = changeset.testing_done
         self.branch = changeset.branch
         self.bugs_closed = ','.join(changeset.bugs_closed)
     @permalink
     def get_absolute_url(self):
         return ('reviewboard.reviews.views.review_detail', None, {
             'review_request_id': self.id,

 from django import template
 from django.db.models import Q
 from django.db.models.query import QuerySet
 from django.template import resolve_variable
 from django.template import NodeList, TemplateSyntaxError, VariableDoesNotExist
 from django.template.loader import render_to_string
 from django.utils import simplejson
 from djblets.util.decorators import blocktag
-from reviewboard.accounts.models import ReviewRequestVisit
+from reviewboard.accounts.models import ReviewRequest, ReviewRequestVisit
-from reviewboard.reviews.db import get_all_review_requests, \
-                                   get_review_requests_from_user, \
-                                   get_review_requests_to_user, \
-                                   get_review_requests_to_user_directly, \
-                                   get_review_requests_to_group
 from reviewboard.reviews.models import ReviewRequestDraft, ScreenshotComment
 from reviewboard.utils.templatetags.htmlutils import humanize_

Review Board

beta

This change has been marked as submitted.

Replace reviews.db with a ReviewRequestManager

Diff revision 1 (Latest)