Changeset - 8ad40ef0ea80
Parent rev.
Child rev.
[Not reviewed]
default
0 4 0
Søren Løvborg - 9 years ago 2016-09-15 13:36:05
sorenl@unity3d.com
db: add some PullRequest.query() shortcuts

This makes database query code more explicit and increases readability.

E.g. the function name get_pullrequest_cnt_for_user was bad, because the
concept of "pullrequest for user" is incredibly vague, and could refer
to any kind of association between PRs and users. (Quiz time! Does it
mean that the user is the PR owner, that the user is reviewing, or that
the user has commented on the PR and thus is receiving notifications?)

A descriptive name could be "get_open_pull_request_count_for_reviewer",
because the function is indeed only concerned with reviewers and only
with open pull requests. But at this point, we might as well say
PullRequest.query(reviewer_id=user, include_closed=False).count()
which is only slightly longer, and doesn't require us to write dozens
of little wrapper functions (including, any moment now, a separate
function for listing the PRs instead of counting them).

Note that we're not actually going down an abstraction level by doing
this. We're still operating on the concepts of "pull request", "open"
and "reviewer", and are not leaking database implementation details.

The query() shortcuts are designed so they default to not altering
the query. Any processing requires explicit opt-in by the caller.
4 files changed with 41 insertions and 40 deletions:
kallithea/controllers/pullrequests.py
16
16
kallithea/lib/base.py
2
3
kallithea/model/db.py
23
kallithea/model/pull_request.py
21
0 comments (0 inline, 0 general)
kallithea/controllers/pullrequests.py
➞
Show inline comments
 
@@ -150,127 +150,127 @@ class PullrequestsController(BaseRepoCon
 
            selected = 'rev:%s:%s' % (rev, rev)
 
            specials = [(selected, '%s: %s' % (_("Changeset"), rev[:12]))]
 

			




	
	
	
		
 
        # prio 3: most recent peer branch

			




	
	
	
		
 
        if peers and not selected:

			




	
	
	
		
 
            selected = peers[0][0]

			




	
	
	
		
 

			




	
	
	
		
 
        # prio 4: tip revision

			




	
	
	
		
 
        if not selected:

			




	
	
	
		
 
            if h.is_hg(repo):

			




	
	
	
		
 
                if tipbranch:

			




	
	
	
		
 
                    selected = 'branch:%s:%s' % (tipbranch, tiprev)

			




	
	
	
		
 
                else:

			




	
	
	
		
 
                    selected = 'tag:null:' + repo.EMPTY_CHANGESET

			




	
	
	
		
 
                    tags.append((selected, 'null'))

			




	
	
	
		
 
            else:

			




	
	
	
		
 
                if 'master' in repo.branches:

			




	
	
	
		
 
                    selected = 'branch:master:%s' % repo.branches['master']

			




	
	
	
		
 
                else:

			




	
	
	
		
 
                    k, v = repo.branches.items()[0]

			




	
	
	
		
 
                    selected = 'branch:%s:%s' % (k, v)

			




	
	
	
		
 

			




	
	
	
		
 
        groups = [(specials, _("Special")),

			




	
	
	
		
 
                  (peers, _("Peer branches")),

			




	
	
	
		
 
                  (bookmarks, _("Bookmarks")),

			




	
	
	
		
 
                  (branches, _("Branches")),

			




	
	
	
		
 
                  (tags, _("Tags")),

			




	
	
	
		
 
                  ]

			




	
	
	
		
 
        return [g for g in groups if g[0]], selected

			




	
	
	
		
 

			




	
	
	
		
 
    def _get_is_allowed_change_status(self, pull_request):

			




	
	
	
		
 
        if pull_request.is_closed():

			




	
	
	
		
 
            return False

			




	
	
	
		
 

			




	
	
	
		
 
        owner = self.authuser.user_id == pull_request.user_id

			




	
	
	
		
 
        reviewer = PullRequestReviewers.query() \

			




	
	
	
		
 
            .filter(PullRequestReviewers.pull_request == pull_request) \

			




	
	
	
		
 
            .filter(PullRequestReviewers.user_id == self.authuser.user_id) \

			




	
	
	
		
 
            .count() != 0

			




	
	
	
		
 

			




	
	
	
		
 
        return self.authuser.admin or owner or reviewer

			




	
	
	
		
 

			




	
	
	
		
 
    @LoginRequired()

			




	
	
	
		
 
    @HasRepoPermissionAnyDecorator('repository.read', 'repository.write',

			




	
	
	
		
 
                                   'repository.admin')

			




	
	
	
		
 
    def show_all(self, repo_name):

			




	
	
	
		
 
        c.from_ = request.GET.get('from_') or ''

			




	
	
	
		
 
        c.closed = request.GET.get('closed') or ''

			




	
	
	
		
 
        c.pull_requests = PullRequestModel().get_all(repo_name, from_=c.from_, closed=c.closed)

			




	
	
	
		
 
        p = safe_int(request.GET.get('page'), 1)

			




	
	
	
		
 

			




	
	
	
		
 
        q = PullRequest.query(include_closed=c.closed, sorted=True)

			




	
	
	
		
 
        if c.from_:

			




	
	
	
		
 
            q = q.filter_by(org_repo=c.db_repo)

			




	
	
	
		
 
        else:

			




	
	
	
		
 
            q = q.filter_by(other_repo=c.db_repo)

			




	
	
	
		
 
        c.pull_requests = q.all()

			




	
	
	
		
 

			




	
	
	
		
 
        c.pullrequests_pager = Page(c.pull_requests, page=p, items_per_page=100)

			




	
	
	
		
 

			




	
	
	
		
 
        return render('/pullrequests/pullrequest_show_all.html')

			




	
	
	
		
 

			




	
	
	
		
 
    @LoginRequired()

			




	
	
	
		
 
    @NotAnonymous()

			




	
	
	
		
 
    def show_my(self):

			




	
	
	
		
 
        c.closed = request.GET.get('closed') or ''

			




	
	
	
		
 

			




	
	
	
		
 
        def _filter(pr):

			




	
	
	
		
 
            s = sorted(pr, key=lambda o: o.created_on, reverse=True)

			




	
	
	
		
 
            if not c.closed:

			




	
	
	
		
 
                s = filter(lambda p: p.status != PullRequest.STATUS_CLOSED, s)

			




	
	
	
		
 
            return s

			




	
	
	
		
 

			




	
	
	
		
 
        c.my_pull_requests = _filter(PullRequest.query() \

			




	
	
	
		
 
                                .filter(PullRequest.user_id ==

			




	
	
	
		
 
                                        self.authuser.user_id) \

			




	
	
	
		
 
                                .all())

			




	
	
	
		
 
        c.my_pull_requests = PullRequest.query(

			




	
	
	
		
 
            include_closed=c.closed,

			




	
	
	
		
 
            sorted=True,

			




	
	
	
		
 
        ).filter_by(user_id=self.authuser.user_id).all()

			




	
	
	
		
 

			




	
	
	
		
 
        c.participate_in_pull_requests = []

			




	
	
	
		
 
        c.participate_in_pull_requests_todo = []

			




	
	
	
		
 
        done_status = set([ChangesetStatus.STATUS_APPROVED, ChangesetStatus.STATUS_REJECTED])

			




	
	
	
		
 
        for pr in _filter(PullRequest.query()

			




	
	
	
		
 
                                .join(PullRequestReviewers)

			




	
	
	
		
 
                                .filter(PullRequestReviewers.user_id ==

			




	
	
	
		
 
                                        self.authuser.user_id)

			




	
	
	
		
 
                         ):

			




	
	
	
		
 
        for pr in PullRequest.query(

			




	
	
	
		
 
            include_closed=c.closed,

			




	
	
	
		
 
            reviewer_id=self.authuser.user_id,

			




	
	
	
		
 
            sorted=True,

			




	
	
	
		
 
        ):

			




	
	
	
		
 
            status = pr.user_review_status(c.authuser.user_id) # very inefficient!!!

			




	
	
	
		
 
            if status in done_status:

			




	
	
	
		
 
                c.participate_in_pull_requests.append(pr)

			




	
	
	
		
 
            else:

			




	
	
	
		
 
                c.participate_in_pull_requests_todo.append(pr)

			




	
	
	
		
 

			




	
	
	
		
 
        return render('/pullrequests/pullrequest_show_my.html')

			




	
	
	
		
 

			




	
	
	
		
 
    @LoginRequired()

			




	
	
	
		
 
    @NotAnonymous()

			




	
	
	
		
 
    @HasRepoPermissionAnyDecorator('repository.read', 'repository.write',

			




	
	
	
		
 
                                   'repository.admin')

			




	
	
	
		
 
    def index(self):

			




	
	
	
		
 
        org_repo = c.db_repo

			




	
	
	
		
 
        org_scm_instance = org_repo.scm_instance

			




	
	
	
		
 
        try:

			




	
	
	
		
 
            org_scm_instance.get_changeset()

			




	
	
	
		
 
        except EmptyRepositoryError as e:

			




	
	
	
		
 
            h.flash(h.literal(_('There are no changesets yet')),

			




	
	
	
		
 
                    category='warning')

			




	
	
	
		
 
            raise HTTPFound(location=url('summary_home', repo_name=org_repo.repo_name))

			




	
	
	
		
 

			




	
	
	
		
 
        org_rev = request.GET.get('rev_end')

			




	
	
	
		
 
        # rev_start is not directly useful - its parent could however be used

			




	
	
	
		
 
        # as default for other and thus give a simple compare view

			




	
	
	
		
 
        rev_start = request.GET.get('rev_start')

			




	
	
	
		
 
        other_rev = None

			




	
	
	
		
 
        if rev_start:

			




	
	
	
		
 
            starters = org_repo.get_changeset(rev_start).parents

			




	
	
	
		
 
            if starters:

			




	
	
	
		
 
                other_rev = starters[0].raw_id

			




	
	
	
		
 
            else:

			




	
	
	
		
 
                other_rev = org_repo.scm_instance.EMPTY_CHANGESET

			




	
	
	
		
 
        branch = request.GET.get('branch')

			




	
	
	
		
 

			




	
	
	
		
 
        c.cs_repos = [(org_repo.repo_name, org_repo.repo_name)]

			




	
	
	
		
 
        c.default_cs_repo = org_repo.repo_name

			




	
	
	
		
 
        c.cs_refs, c.default_cs_ref = self._get_repo_refs(org_scm_instance, rev=org_rev, branch=branch)

			




	
	
	
		
 

			




	
	
	
		
 
        default_cs_ref_type, default_cs_branch, default_cs_rev = c.default_cs_ref.split(':')

			




	
	
	
		
 
        if default_cs_ref_type != 'branch':

			




	
	
	
		
 
            default_cs_branch = org_repo.get_changeset(default_cs_rev).branch

			




	
	
	
		
 

			




	
	
	
		
 
        # add org repo to other so we can open pull request against peer branches on itself

			




	
	
	
		
 
        c.a_repos = [(org_repo.repo_name, '%s (self)' % org_repo.repo_name)]

			




	
	
	
		
 

			




	
	
	
		
 
        if org_repo.parent:

			




	
	
	
		
 
            # add parent of this fork also and select it.

			




        

    


    
    

    

        

                

                    kallithea/lib/base.py
                

                

                  
                      
                        

                      ➞

                      
                        
                  

                  
                      
                  
                      
                  
                      
                  
                      
                  
                  
                

                

                    Show inline comments
                    
                

        

        

            



	
	
		
 
@@ -10,100 +10,99 @@

			




	
	
	
		
 
# GNU General Public License for more details.

			




	
	
	
		
 
#

			




	
	
	
		
 
# You should have received a copy of the GNU General Public License

			




	
	
	
		
 
# along with this program.  If not, see <http://www.gnu.org/licenses/>.

			




	
	
	
		
 

			




	
	
	
		
 
"""

			




	
	
	
		
 
kallithea.lib.base

			




	
	
	
		
 
~~~~~~~~~~~~~~~~~~

			




	
	
	
		
 

			




	
	
	
		
 
The base Controller API

			




	
	
	
		
 
Provides the BaseController class for subclassing. And usage in different

			




	
	
	
		
 
controllers

			




	
	
	
		
 

			




	
	
	
		
 
This file was forked by the Kallithea project in July 2014.

			




	
	
	
		
 
Original author and date, and relevant copyright and licensing information is below:

			




	
	
	
		
 
:created_on: Oct 06, 2010

			




	
	
	
		
 
:author: marcink

			




	
	
	
		
 
:copyright: (c) 2013 RhodeCode GmbH, and others.

			




	
	
	
		
 
:license: GPLv3, see LICENSE.md for more details.

			




	
	
	
		
 
"""

			




	
	
	
		
 

			




	
	
	
		
 
import datetime

			




	
	
	
		
 
import logging

			




	
	
	
		
 
import time

			




	
	
	
		
 
import traceback

			




	
	
	
		
 

			




	
	
	
		
 
import webob.exc

			




	
	
	
		
 
import paste.httpexceptions

			




	
	
	
		
 
import paste.auth.basic

			




	
	
	
		
 
import paste.httpheaders

			




	
	
	
		
 

			




	
	
	
		
 
from pylons import config, tmpl_context as c, request, session

			




	
	
	
		
 
from pylons.controllers import WSGIController

			




	
	
	
		
 
from pylons.templating import render_mako as render  # don't remove this import

			




	
	
	
		
 
from pylons.i18n.translation import _

			




	
	
	
		
 

			




	
	
	
		
 
from kallithea import __version__, BACKENDS

			




	
	
	
		
 

			




	
	
	
		
 
from kallithea.config.routing import url

			




	
	
	
		
 
from kallithea.lib.utils2 import str2bool, safe_unicode, AttributeDict, \

			




	
	
	
		
 
    safe_str, safe_int

			




	
	
	
		
 
from kallithea.lib import auth_modules

			




	
	
	
		
 
from kallithea.lib.auth import AuthUser, HasPermissionAnyMiddleware

			




	
	
	
		
 
from kallithea.lib.utils import get_repo_slug

			




	
	
	
		
 
from kallithea.lib.exceptions import UserCreationError

			




	
	
	
		
 
from kallithea.lib.vcs.exceptions import RepositoryError, EmptyRepositoryError, ChangesetDoesNotExistError

			




	
	
	
		
 
from kallithea.model import meta

			




	
	
	
		
 

			




	
	
	
		
 
from kallithea.model.db import Repository, Ui, User, Setting

			




	
	
	
		
 
from kallithea.model.db import PullRequest, Repository, Ui, User, Setting

			




	
	
	
		
 
from kallithea.model.notification import NotificationModel

			




	
	
	
		
 
from kallithea.model.scm import ScmModel

			




	
	
	
		
 
from kallithea.model.pull_request import PullRequestModel

			




	
	
	
		
 

			




	
	
	
		
 
log = logging.getLogger(__name__)

			




	
	
	
		
 

			




	
	
	
		
 

			




	
	
	
		
 
def _filter_proxy(ip):

			




	
	
	
		
 
    """

			




	
	
	
		
 
    HEADERS can have multiple ips inside the left-most being the original

			




	
	
	
		
 
    client, and each successive proxy that passed the request adding the IP

			




	
	
	
		
 
    address where it received the request from.

			




	
	
	
		
 

			




	
	
	
		
 
    :param ip:

			




	
	
	
		
 
    """

			




	
	
	
		
 
    if ',' in ip:

			




	
	
	
		
 
        _ips = ip.split(',')

			




	
	
	
		
 
        _first_ip = _ips[0].strip()

			




	
	
	
		
 
        log.debug('Got multiple IPs %s, using %s', ','.join(_ips), _first_ip)

			




	
	
	
		
 
        return _first_ip

			




	
	
	
		
 
    return ip

			




	
	
	
		
 

			




	
	
	
		
 

			




	
	
	
		
 
def _get_ip_addr(environ):

			




	
	
	
		
 
    proxy_key = 'HTTP_X_REAL_IP'

			




	
	
	
		
 
    proxy_key2 = 'HTTP_X_FORWARDED_FOR'

			




	
	
	
		
 
    def_key = 'REMOTE_ADDR'

			




	
	
	
		
 

			




	
	
	
		
 
    ip = environ.get(proxy_key)

			




	
	
	
		
 
    if ip:

			




	
	
	
		
 
        return _filter_proxy(ip)

			




	
	
	
		
 

			




	
	
	
		
 
    ip = environ.get(proxy_key2)

			




	
	
	
		
 
    if ip:

			




	
	
	
		
 
        return _filter_proxy(ip)

			




	
	
	
		
 

			




	
	
	
		
 
    ip = environ.get(def_key, '0.0.0.0')

			




	
	
	
		
 
    return _filter_proxy(ip)

			




	
	
	
		
 

			




	
	
	
		
 

			




	
	
	
		
 
def _get_access_path(environ):

			




	
	
	
		
 
    path = environ.get('PATH_INFO')

			




	
	
	
		
 
    org_req = environ.get('pylons.original_request')

			




	
	
	
		
 
    if org_req:

			




	
	
	
		
 
        path = org_req.environ.get('PATH_INFO')

			




	
	
	
		
 
    return path

			




	
	
	
		
 

			




	
	
	
		
 

			




	
	
	
		
 
def log_in_user(user, remember, is_external_auth):

			




	
	
	
		
 
    """

			




	
	
	
		
 
    Log a `User` in and update session and cookies. If `remember` is True,

			




	
	
		
 
@@ -314,97 +313,97 @@ class BaseController(WSGIController):

			




	
	
	
		
 
        rc_config = Setting.get_app_settings()

			




	
	
	
		
 

			




	
	
	
		
 
        # Visual options

			




	
	
	
		
 
        c.visual = AttributeDict({})

			




	
	
	
		
 

			




	
	
	
		
 
        ## DB stored

			




	
	
	
		
 
        c.visual.show_public_icon = str2bool(rc_config.get('show_public_icon'))

			




	
	
	
		
 
        c.visual.show_private_icon = str2bool(rc_config.get('show_private_icon'))

			




	
	
	
		
 
        c.visual.stylify_metatags = str2bool(rc_config.get('stylify_metatags'))

			




	
	
	
		
 
        c.visual.dashboard_items = safe_int(rc_config.get('dashboard_items', 100))

			




	
	
	
		
 
        c.visual.admin_grid_items = safe_int(rc_config.get('admin_grid_items', 100))

			




	
	
	
		
 
        c.visual.repository_fields = str2bool(rc_config.get('repository_fields'))

			




	
	
	
		
 
        c.visual.show_version = str2bool(rc_config.get('show_version'))

			




	
	
	
		
 
        c.visual.use_gravatar = str2bool(rc_config.get('use_gravatar'))

			




	
	
	
		
 
        c.visual.gravatar_url = rc_config.get('gravatar_url')

			




	
	
	
		
 

			




	
	
	
		
 
        c.ga_code = rc_config.get('ga_code')

			




	
	
	
		
 
        # TODO: replace undocumented backwards compatibility hack with db upgrade and rename ga_code

			




	
	
	
		
 
        if c.ga_code and '<' not in c.ga_code:

			




	
	
	
		
 
            c.ga_code = '''<script type="text/javascript">

			




	
	
	
		
 
                var _gaq = _gaq || [];

			




	
	
	
		
 
                _gaq.push(['_setAccount', '%s']);

			




	
	
	
		
 
                _gaq.push(['_trackPageview']);

			




	
	
	
		
 

			




	
	
	
		
 
                (function() {

			




	
	
	
		
 
                    var ga = document.createElement('script'); ga.type = 'text/javascript'; ga.async = true;

			




	
	
	
		
 
                    ga.src = ('https:' == document.location.protocol ? 'https://ssl' : 'http://www') + '.google-analytics.com/ga.js';

			




	
	
	
		
 
                    var s = document.getElementsByTagName('script')[0]; s.parentNode.insertBefore(ga, s);

			




	
	
	
		
 
                    })();

			




	
	
	
		
 
            </script>''' % c.ga_code

			




	
	
	
		
 
        c.site_name = rc_config.get('title')

			




	
	
	
		
 
        c.clone_uri_tmpl = rc_config.get('clone_uri_tmpl')

			




	
	
	
		
 

			




	
	
	
		
 
        ## INI stored

			




	
	
	
		
 
        c.visual.allow_repo_location_change = str2bool(config.get('allow_repo_location_change', True))

			




	
	
	
		
 
        c.visual.allow_custom_hooks_settings = str2bool(config.get('allow_custom_hooks_settings', True))

			




	
	
	
		
 

			




	
	
	
		
 
        c.instance_id = config.get('instance_id')

			




	
	
	
		
 
        c.issues_url = config.get('bugtracker', url('issues_url'))

			




	
	
	
		
 
        # END CONFIG VARS

			




	
	
	
		
 

			




	
	
	
		
 
        c.repo_name = get_repo_slug(request)  # can be empty

			




	
	
	
		
 
        c.backends = BACKENDS.keys()

			




	
	
	
		
 
        c.unread_notifications = NotificationModel() \

			




	
	
	
		
 
                        .get_unread_cnt_for_user(c.authuser.user_id)

			




	
	
	
		
 

			




	
	
	
		
 
        self.cut_off_limit = safe_int(config.get('cut_off_limit'))

			




	
	
	
		
 

			




	
	
	
		
 
        c.my_pr_count = PullRequestModel().get_pullrequest_cnt_for_user(c.authuser.user_id)

			




	
	
	
		
 
        c.my_pr_count = PullRequest.query(reviewer_id=c.authuser.user_id, include_closed=False).count()

			




	
	
	
		
 

			




	
	
	
		
 
        self.sa = meta.Session

			




	
	
	
		
 
        self.scm_model = ScmModel(self.sa)

			




	
	
	
		
 

			




	
	
	
		
 
    @staticmethod

			




	
	
	
		
 
    def _determine_auth_user(api_key, session_authuser):

			




	
	
	
		
 
        """

			




	
	
	
		
 
        Create an `AuthUser` object given the API key (if any) and the

			




	
	
	
		
 
        value of the authuser session cookie.

			




	
	
	
		
 
        """

			




	
	
	
		
 

			




	
	
	
		
 
        # Authenticate by API key

			




	
	
	
		
 
        if api_key:

			




	
	
	
		
 
            # when using API_KEY we are sure user exists.

			




	
	
	
		
 
            return AuthUser(dbuser=User.get_by_api_key(api_key),

			




	
	
	
		
 
                            is_external_auth=True)

			




	
	
	
		
 

			




	
	
	
		
 
        # Authenticate by session cookie

			




	
	
	
		
 
        # In ancient login sessions, 'authuser' may not be a dict.

			




	
	
	
		
 
        # In that case, the user will have to log in again.

			




	
	
	
		
 
        # v0.3 and earlier included an 'is_authenticated' key; if present,

			




	
	
	
		
 
        # this must be True.

			




	
	
	
		
 
        if isinstance(session_authuser, dict) and session_authuser.get('is_authenticated', True):

			




	
	
	
		
 
            try:

			




	
	
	
		
 
                return AuthUser.from_cookie(session_authuser)

			




	
	
	
		
 
            except UserCreationError as e:

			




	
	
	
		
 
                # container auth or other auth functions that create users on

			




	
	
	
		
 
                # the fly can throw UserCreationError to signal issues with

			




	
	
	
		
 
                # user creation. Explanation should be provided in the

			




	
	
	
		
 
                # exception object.

			




	
	
	
		
 
                from kallithea.lib import helpers as h

			




	
	
	
		
 
                h.flash(e, 'error', logf=log.error)

			




	
	
	
		
 

			




	
	
	
		
 
        # Authenticate by auth_container plugin (if enabled)

			




	
	
	
		
 
        if any(

			




	
	
	
		
 
            auth_modules.importplugin(name).is_container_auth

			




	
	
	
		
 
            for name in Setting.get_auth_plugins()

			




	
	
	
		
 
        ):

			




	
	
	
		
 
            try:

			




	
	
	
		
 
                user_info = auth_modules.authenticate('', '', request.environ)

			




	
	
	
		
 
            except UserCreationError as e:

			




	
	
	
		
 
                from kallithea.lib import helpers as h

			




	
	
	
		
 
                h.flash(e, 'error', logf=log.error)

			




	
	
	
		
 
            else:

			




	
	
	
		
 
                if user_info is not None:

			




	
	
	
		
 
                    username = user_info['username']

			




	
	
	
		
 
                    user = User.get_by_username(username, case_insensitive=True)

			




	
	
	
		
 
                    return log_in_user(user, remember=False,

			




        

    


    
    

    

        

                

                    kallithea/model/db.py
                

                

                  
                      
                        

                      ➞

                      
                        
                  

                  
                      
                  
                      
                  
                      
                  
                      
                  
                  
                

                

                    Show inline comments
                    
                

        

        

            



	
	
		
 
@@ -2295,96 +2295,119 @@ class PullRequest(Base, BaseModel):

			




	
	
	
		
 
    __table_args__ = (

			




	
	
	
		
 
        Index('pr_org_repo_id_idx', 'org_repo_id'),

			




	
	
	
		
 
        Index('pr_other_repo_id_idx', 'other_repo_id'),

			




	
	
	
		
 
        _table_args_default_dict,

			




	
	
	
		
 
    )

			




	
	
	
		
 

			




	
	
	
		
 
    # values for .status

			




	
	
	
		
 
    STATUS_NEW = u'new'

			




	
	
	
		
 
    STATUS_CLOSED = u'closed'

			




	
	
	
		
 

			




	
	
	
		
 
    pull_request_id = Column(Integer(), primary_key=True)

			




	
	
	
		
 
    title = Column(Unicode(255), nullable=False)

			




	
	
	
		
 
    description = Column(UnicodeText(), nullable=False)

			




	
	
	
		
 
    status = Column(Unicode(255), nullable=False, default=STATUS_NEW) # only for closedness, not approve/reject/etc

			




	
	
	
		
 
    created_on = Column(DateTime(timezone=False), nullable=False, default=datetime.datetime.now)

			




	
	
	
		
 
    updated_on = Column(DateTime(timezone=False), nullable=False, default=datetime.datetime.now)

			




	
	
	
		
 
    user_id = Column(Integer(), ForeignKey('users.user_id'), nullable=False)

			




	
	
	
		
 
    _revisions = Column('revisions', UnicodeText(), nullable=False)

			




	
	
	
		
 
    org_repo_id = Column(Integer(), ForeignKey('repositories.repo_id'), nullable=False)

			




	
	
	
		
 
    org_ref = Column(Unicode(255), nullable=False)

			




	
	
	
		
 
    other_repo_id = Column(Integer(), ForeignKey('repositories.repo_id'), nullable=False)

			




	
	
	
		
 
    other_ref = Column(Unicode(255), nullable=False)

			




	
	
	
		
 

			




	
	
	
		
 
    @hybrid_property

			




	
	
	
		
 
    def revisions(self):

			




	
	
	
		
 
        return self._revisions.split(':')

			




	
	
	
		
 

			




	
	
	
		
 
    @revisions.setter

			




	
	
	
		
 
    def revisions(self, val):

			




	
	
	
		
 
        self._revisions = safe_unicode(':'.join(val))

			




	
	
	
		
 

			




	
	
	
		
 
    @property

			




	
	
	
		
 
    def org_ref_parts(self):

			




	
	
	
		
 
        return self.org_ref.split(':')

			




	
	
	
		
 

			




	
	
	
		
 
    @property

			




	
	
	
		
 
    def other_ref_parts(self):

			




	
	
	
		
 
        return self.other_ref.split(':')

			




	
	
	
		
 

			




	
	
	
		
 
    owner = relationship('User')

			




	
	
	
		
 
    reviewers = relationship('PullRequestReviewers',

			




	
	
	
		
 
                             cascade="all, delete-orphan")

			




	
	
	
		
 
    org_repo = relationship('Repository', primaryjoin='PullRequest.org_repo_id==Repository.repo_id')

			




	
	
	
		
 
    other_repo = relationship('Repository', primaryjoin='PullRequest.other_repo_id==Repository.repo_id')

			




	
	
	
		
 
    statuses = relationship('ChangesetStatus', order_by='ChangesetStatus.changeset_status_id')

			




	
	
	
		
 
    comments = relationship('ChangesetComment', order_by='ChangesetComment.comment_id',

			




	
	
	
		
 
                             cascade="all, delete-orphan")

			




	
	
	
		
 

			




	
	
	
		
 
    @classmethod

			




	
	
	
		
 
    def query(cls, reviewer_id=None, include_closed=True, sorted=False):

			




	
	
	
		
 
        """Add PullRequest-specific helpers for common query constructs.

			




	
	
	
		
 

			




	
	
	
		
 
        reviewer_id: only PRs with the specified user added as reviewer.

			




	
	
	
		
 

			




	
	
	
		
 
        include_closed: if False, do not include closed PRs.

			




	
	
	
		
 

			




	
	
	
		
 
        sorted: if True, apply the default ordering (newest first).

			




	
	
	
		
 
        """

			




	
	
	
		
 
        q = super(PullRequest, cls).query()

			




	
	
	
		
 

			




	
	
	
		
 
        if reviewer_id is not None:

			




	
	
	
		
 
            q = q.join(PullRequestReviewers).filter(PullRequestReviewers.user_id == reviewer_id)

			




	
	
	
		
 

			




	
	
	
		
 
        if not include_closed:

			




	
	
	
		
 
            q = q.filter(PullRequest.status != PullRequest.STATUS_CLOSED)

			




	
	
	
		
 

			




	
	
	
		
 
        if sorted:

			




	
	
	
		
 
            q = q.order_by(PullRequest.created_on.desc())

			




	
	
	
		
 

			




	
	
	
		
 
        return q

			




	
	
	
		
 

			




	
	
	
		
 
    def get_reviewer_users(self):

			




	
	
	
		
 
        """Like .reviewers, but actually returning the users"""

			




	
	
	
		
 
        return User.query() \

			




	
	
	
		
 
            .join(PullRequestReviewers) \

			




	
	
	
		
 
            .filter(PullRequestReviewers.pull_request == self) \

			




	
	
	
		
 
            .order_by(PullRequestReviewers.pull_requests_reviewers_id) \

			




	
	
	
		
 
            .all()

			




	
	
	
		
 

			




	
	
	
		
 
    def is_closed(self):

			




	
	
	
		
 
        return self.status == self.STATUS_CLOSED

			




	
	
	
		
 

			




	
	
	
		
 
    def user_review_status(self, user_id):

			




	
	
	
		
 
        """Return the user's latest status votes on PR"""

			




	
	
	
		
 
        # note: no filtering on repo - that would be redundant

			




	
	
	
		
 
        status = ChangesetStatus.query() \

			




	
	
	
		
 
            .filter(ChangesetStatus.pull_request == self) \

			




	
	
	
		
 
            .filter(ChangesetStatus.user_id == user_id) \

			




	
	
	
		
 
            .order_by(ChangesetStatus.version) \

			




	
	
	
		
 
            .first()

			




	
	
	
		
 
        return str(status.status) if status else ''

			




	
	
	
		
 

			




	
	
	
		
 
    @classmethod

			




	
	
	
		
 
    def make_nice_id(cls, pull_request_id):

			




	
	
	
		
 
        '''Return pull request id nicely formatted for displaying'''

			




	
	
	
		
 
        return '#%s' % pull_request_id

			




	
	
	
		
 

			




	
	
	
		
 
    def nice_id(self):

			




	
	
	
		
 
        '''Return the id of this pull request, nicely formatted for displaying'''

			




	
	
	
		
 
        return self.make_nice_id(self.pull_request_id)

			




	
	
	
		
 

			




	
	
	
		
 
    def __json__(self):

			




	
	
	
		
 
        return dict(

			




	
	
	
		
 
            revisions=self.revisions

			




	
	
	
		
 
        )

			




	
	
	
		
 

			




	
	
	
		
 
    def url(self, **kwargs):

			




	
	
	
		
 
        canonical = kwargs.pop('canonical', None)

			




	
	
	
		
 
        import kallithea.lib.helpers as h

			




	
	
	
		
 
        b = self.org_ref_parts[1]

			




	
	
	
		
 
        if b != self.other_ref_parts[1]:

			




	
	
	
		
 
            s = '/_/' + b

			




	
	
	
		
 
        else:

			




	
	
	
		
 
            s = '/_/' + self.title

			




	
	
	
		
 
        kwargs['extra'] = urlreadable(s)

			




	
	
	
		
 
        if canonical:

			




	
	
	
		
 
            return h.canonical_url('pullrequest_show', repo_name=self.other_repo.repo_name,

			




	
	
	
		
 
                                   pull_request_id=self.pull_request_id, **kwargs)

			




	
	
	
		
 
        return h.url('pullrequest_show', repo_name=self.other_repo.repo_name,

			




        

    


    
    

    

        

                

                    kallithea/model/pull_request.py
                

                

                  
                      
                        

                      ➞

                      
                        
                  

                  
                      
                  
                      
                  
                      
                  
                      
                  
                  
                

                

                    Show inline comments
                    
                

        

        

            



	
	
		
 
@@ -2,117 +2,96 @@

			




	
	
	
		
 
# This program is free software: you can redistribute it and/or modify

			




	
	
	
		
 
# it under the terms of the GNU General Public License as published by

			




	
	
	
		
 
# the Free Software Foundation, either version 3 of the License, or

			




	
	
	
		
 
# (at your option) any later version.

			




	
	
	
		
 
#

			




	
	
	
		
 
# This program is distributed in the hope that it will be useful,

			




	
	
	
		
 
# but WITHOUT ANY WARRANTY; without even the implied warranty of

			




	
	
	
		
 
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

			




	
	
	
		
 
# GNU General Public License for more details.

			




	
	
	
		
 
#

			




	
	
	
		
 
# You should have received a copy of the GNU General Public License

			




	
	
	
		
 
# along with this program.  If not, see <http://www.gnu.org/licenses/>.

			




	
	
	
		
 
"""

			




	
	
	
		
 
kallithea.model.pull_request

			




	
	
	
		
 
~~~~~~~~~~~~~~~~~~~~~~~~~~~~

			




	
	
	
		
 

			




	
	
	
		
 
pull request model for Kallithea

			




	
	
	
		
 

			




	
	
	
		
 
This file was forked by the Kallithea project in July 2014.

			




	
	
	
		
 
Original author and date, and relevant copyright and licensing information is below:

			




	
	
	
		
 
:created_on: Jun 6, 2012

			




	
	
	
		
 
:author: marcink

			




	
	
	
		
 
:copyright: (c) 2013 RhodeCode GmbH, and others.

			




	
	
	
		
 
:license: GPLv3, see LICENSE.md for more details.

			




	
	
	
		
 
"""

			




	
	
	
		
 

			




	
	
	
		
 
import logging

			




	
	
	
		
 
import datetime

			




	
	
	
		
 

			




	
	
	
		
 
from pylons.i18n.translation import _

			




	
	
	
		
 

			




	
	
	
		
 
from sqlalchemy.orm import joinedload

			




	
	
	
		
 

			




	
	
	
		
 
from kallithea.model.meta import Session

			




	
	
	
		
 
from kallithea.lib import helpers as h

			




	
	
	
		
 
from kallithea.lib.exceptions import UserInvalidException

			




	
	
	
		
 
from kallithea.model import BaseModel

			




	
	
	
		
 
from kallithea.model.db import PullRequest, PullRequestReviewers, Notification, \

			




	
	
	
		
 
    ChangesetStatus, User

			




	
	
	
		
 
from kallithea.model.notification import NotificationModel

			




	
	
	
		
 
from kallithea.lib.utils2 import extract_mentioned_users, safe_unicode

			




	
	
	
		
 

			




	
	
	
		
 

			




	
	
	
		
 
log = logging.getLogger(__name__)

			




	
	
	
		
 

			




	
	
	
		
 

			




	
	
	
		
 
class PullRequestModel(BaseModel):

			




	
	
	
		
 

			




	
	
	
		
 
    def get_pullrequest_cnt_for_user(self, user):

			




	
	
	
		
 
        return PullRequest.query() \

			




	
	
	
		
 
                                .join(PullRequestReviewers) \

			




	
	
	
		
 
                                .filter(PullRequestReviewers.user_id == user) \

			




	
	
	
		
 
                                .filter(PullRequest.status != PullRequest.STATUS_CLOSED) \

			




	
	
	
		
 
                                .count()

			




	
	
	
		
 

			




	
	
	
		
 
    def get_all(self, repo_name, from_=False, closed=False):

			




	
	
	
		
 
        """Get all PRs for repo.

			




	
	
	
		
 
        Default is all PRs to the repo, PRs from the repo if from_.

			




	
	
	
		
 
        Closed PRs are only included if closed is true."""

			




	
	
	
		
 
        repo = self._get_repo(repo_name)

			




	
	
	
		
 
        q = PullRequest.query()

			




	
	
	
		
 
        if from_:

			




	
	
	
		
 
            q = q.filter(PullRequest.org_repo == repo)

			




	
	
	
		
 
        else:

			




	
	
	
		
 
            q = q.filter(PullRequest.other_repo == repo)

			




	
	
	
		
 
        if not closed:

			




	
	
	
		
 
            q = q.filter(PullRequest.status != PullRequest.STATUS_CLOSED)

			




	
	
	
		
 
        return q.order_by(PullRequest.created_on.desc()).all()

			




	
	
	
		
 

			




	
	
	
		
 
    def _get_valid_reviewers(self, seq):

			




	
	
	
		
 
        """ Generate User objects from a sequence of user IDs, usernames or

			




	
	
	
		
 
        User objects. Raises UserInvalidException if the DEFAULT user is

			




	
	
	
		
 
        specified, or if a given ID or username does not match any user.

			




	
	
	
		
 
        """

			




	
	
	
		
 
        for user_spec in seq:

			




	
	
	
		
 
            user = self._get_user(user_spec)

			




	
	
	
		
 
            if user is None or user.username == User.DEFAULT_USER:

			




	
	
	
		
 
                raise UserInvalidException(user_spec)

			




	
	
	
		
 
            yield user

			




	
	
	
		
 

			




	
	
	
		
 
    def create(self, created_by, org_repo, org_ref, other_repo, other_ref,

			




	
	
	
		
 
               revisions, reviewers, title, description=None):

			




	
	
	
		
 
        from kallithea.model.changeset_status import ChangesetStatusModel

			




	
	
	
		
 

			




	
	
	
		
 
        created_by_user = self._get_user(created_by)

			




	
	
	
		
 
        org_repo = self._get_repo(org_repo)

			




	
	
	
		
 
        other_repo = self._get_repo(other_repo)

			




	
	
	
		
 

			




	
	
	
		
 
        new = PullRequest()

			




	
	
	
		
 
        new.org_repo = org_repo

			




	
	
	
		
 
        new.org_ref = org_ref

			




	
	
	
		
 
        new.other_repo = other_repo

			




	
	
	
		
 
        new.other_ref = other_ref

			




	
	
	
		
 
        new.revisions = revisions

			




	
	
	
		
 
        new.title = title

			




	
	
	
		
 
        new.description = description

			




	
	
	
		
 
        new.owner = created_by_user

			




	
	
	
		
 
        Session().add(new)

			




	
	
	
		
 
        Session().flush()

			




	
	
	
		
 

			




	
	
	
		
 
        #reset state to under-review

			




	
	
	
		
 
        from kallithea.model.comment import ChangesetCommentsModel

			




	
	
	
		
 
        comment = ChangesetCommentsModel().create(

			




	
	
	
		
 
            text=u'',

			




	
	
	
		
 
            repo=org_repo,

			




	
	
	
		
 
            user=new.owner,

			




	
	
	
		
 
            pull_request=new,

			




	
	
	
		
 
            send_email=False,

			




	
	
	
		
 
            status_change=ChangesetStatus.STATUS_UNDER_REVIEW,

			




	
	
	
		
 
        )

			




	
	
	
		
 
        ChangesetStatusModel().set_status(

			




	
	
	
		
 
            org_repo,

			




	
	
	
		
 
            ChangesetStatus.STATUS_UNDER_REVIEW,

			




	
	
	
		
 
            new.owner,

			




	
	
	
		
 
            comment,

			




	
	
	
		
 
            pull_request=new

			




	
	
	
		
 
        )

			




        

    



    


    



    



      

      





    
    0 comments (0 inline, 0 general)
    





    


  

  







  


    




    








    
        
    
    
        This site is powered by
            Kallithea 0.7.0,
        which is
        © 2010–2025 by various authors & licensed under GPLv3.