kallithea Changeset - 1bc579bcd67a

Changeset - 1bc579bcd67a

Parent rev.

Child rev.

[Not reviewed]

codereview

0 11 1

Marcin Kuzminski - 13 years ago 2012-06-10 18:15:00
marcin@python-works.com

- pull request generates overview based on it's params
- added page to show all pull-requests for a repository
- db schema changes to support comments and inline comments for pull-requests

12 files changed with 299 insertions and 44 deletions:

rhodecode/config/routing.py

rhodecode/controllers/changeset.py

rhodecode/controllers/pullrequests.py

131

rhodecode/lib/base.py

rhodecode/model/changeset_status.py

rhodecode/model/comment.py

rhodecode/model/db.py

rhodecode/model/pull_request.py

rhodecode/model/scm.py

rhodecode/templates/base/base.html

rhodecode/templates/pullrequests/pullrequest_show.html

rhodecode/templates/pullrequests/pullrequest_show_all.html

0 comments (0 inline, 0 general)

rhodecode/config/routing.py

➞

Show inline comments

@@ @@ -406,96 +406,102 @@ def make_map(config): @@
                 conditions=dict(function=check_repo))
     rmap.connect('repos_group_home', '/{group_name:.*}',
                 controller='admin/repos_groups', action="show_by_name",
                 conditions=dict(function=check_group))
     rmap.connect('changeset_home', '/{repo_name:.*}/changeset/{revision}',
                 controller='changeset', revision='tip',
                 conditions=dict(function=check_repo))
     rmap.connect('changeset_comment',
                  '/{repo_name:.*}/changeset/{revision}/comment',
                 controller='changeset', revision='tip', action='comment',
                 conditions=dict(function=check_repo))
     rmap.connect('changeset_comment_delete',
                  '/{repo_name:.*}/changeset/comment/{comment_id}/delete',
                 controller='changeset', action='delete_comment',
                 conditions=dict(function=check_repo, method=["DELETE"]))
     rmap.connect('raw_changeset_home',
                  '/{repo_name:.*}/raw-changeset/{revision}',
                  controller='changeset', action='raw_changeset',
                  revision='tip', conditions=dict(function=check_repo))
     rmap.connect('compare_url',
                  '/{repo_name:.*}/compare/{org_ref_type}@{org_ref}...{other_ref_type}@{other_ref}',
                  controller='compare', action='index',
                  conditions=dict(function=check_repo),
                  requirements=dict(org_ref_type='(branch|book|tag)',
                                    other_ref_type='(branch|book|tag)'))
     rmap.connect('pullrequest_home',
                  '/{repo_name:.*}/pull-request/new', controller='pullrequests',
                  action='index', conditions=dict(function=check_repo,
                                                  method=["GET"]))
     rmap.connect('pullrequest',
                  '/{repo_name:.*}/pull-request/new', controller='pullrequests',
                  action='create', conditions=dict(function=check_repo,
                                                   method=["POST"]))
     rmap.connect('pullrequest_show',
                  '/{repo_name:.*}/pull-request/{pull_request_id}',
                  controller='pullrequests',
                  action='show', conditions=dict(function=check_repo,
                                                 method=["GET"]))
     rmap.connect('pullrequest_show_all',
                  '/{repo_name:.*}/pull-request',
                  controller='pullrequests',
                  action='show_all', conditions=dict(function=check_repo,
                                                 method=["GET"]))
     rmap.connect('summary_home', '/{repo_name:.*}/summary',
                 controller='summary', conditions=dict(function=check_repo))
     rmap.connect('shortlog_home', '/{repo_name:.*}/shortlog',
                 controller='shortlog', conditions=dict(function=check_repo))
     rmap.connect('branches_home', '/{repo_name:.*}/branches',
                 controller='branches', conditions=dict(function=check_repo))
     rmap.connect('tags_home', '/{repo_name:.*}/tags',
                 controller='tags', conditions=dict(function=check_repo))
     rmap.connect('bookmarks_home', '/{repo_name:.*}/bookmarks',
                 controller='bookmarks', conditions=dict(function=check_repo))
     rmap.connect('changelog_home', '/{repo_name:.*}/changelog',
                 controller='changelog', conditions=dict(function=check_repo))
     rmap.connect('changelog_details', '/{repo_name:.*}/changelog_details/{cs}',
                 controller='changelog', action='changelog_details',
                 conditions=dict(function=check_repo))
     rmap.connect('files_home', '/{repo_name:.*}/files/{revision}/{f_path:.*}',
                 controller='files', revision='tip', f_path='',
                 conditions=dict(function=check_repo))
     rmap.connect('files_diff_home', '/{repo_name:.*}/diff/{f_path:.*}',
                 controller='files', action='diff', revision='tip', f_path='',
                 conditions=dict(function=check_repo))
     rmap.connect('files_rawfile_home',
                  '/{repo_name:.*}/rawfile/{revision}/{f_path:.*}',
                  controller='files', action='rawfile', revision='tip',
                  f_path='', conditions=dict(function=check_repo))
     rmap.connect('files_raw_home',
                  '/{repo_name:.*}/raw/{revision}/{f_path:.*}',
                  controller='files', action='raw', revision='tip', f_path='',
                  conditions=dict(function=check_repo))
     rmap.connect('files_annotate_home',
                  '/{repo_name:.*}/annotate/{revision}/{f_path:.*}',
                  controller='files', action='index', revision='tip',
                  f_path='', annotate=True, conditions=dict(function=check_repo))
     rmap.connect('files_edit_home',
                  '/{repo_name:.*}/edit/{revision}/{f_path:.*}',
                  controller='files', action='edit', revision='tip',

rhodecode/controllers/changeset.py

➞

Show inline comments

@@ @@ -250,97 +250,97 @@ class ChangesetController(BaseRepoContro @@
                     enable_comments=enable_comments
+                )
                 cumulative_diff += size
                 c.lines_added += st[0]
                 c.lines_deleted += st[1]
                 c.changes[changeset.raw_id].append(
                     ('added', node, diff, cs1, cs2, st)
+                )
             #==================================================================
             # CHANGED FILES
             #==================================================================
             for node in changeset.changed:
                 try:
                     filenode_old = changeset_parent.get_node(node.path)
                 except ChangesetError:
                     log.warning('Unable to fetch parent node for diff')
                     filenode_old = FileNode(node.path, '', EmptyChangeset())
                 fid = h.FID(revision, node.path)
                 line_context_lcl = get_line_ctx(fid, request.GET)
                 ign_whitespace_lcl = get_ignore_ws(fid, request.GET)
                 lim = self.cut_off_limit
                 if cumulative_diff > self.cut_off_limit:
                     lim = -1 if limit_off is None else None
                 size, cs1, cs2, diff, st = wrapped_diff(
                     filenode_old=filenode_old,
                     filenode_new=node,
                     cut_off_limit=lim,
                     ignore_whitespace=ign_whitespace_lcl,
                     line_context=line_context_lcl,
                     enable_comments=enable_comments
+                )
                 cumulative_diff += size
                 c.lines_added += st[0]
                 c.lines_deleted += st[1]
                 c.changes[changeset.raw_id].append(
                     ('changed', node, diff, cs1, cs2, st)
+                )
             #==================================================================
             # REMOVED FILES
             #==================================================================
             for node in changeset.removed:
                 c.changes[changeset.raw_id].append(
                     ('removed', node, None, None, None, (0, 0))
+                )
         # count inline comments
-        for _, lines in c.inline_comments:
+        for __, lines in c.inline_comments:
             for comments in lines.values():
                 c.inline_cnt += len(comments)
         if len(c.cs_ranges) == 1:
             c.changeset = c.cs_ranges[0]
             c.changes = c.changes[c.changeset.raw_id]
             return render('changeset/changeset.html')
         else:
             return render('changeset/changeset_range.html')
     def raw_changeset(self, revision):
         method = request.GET.get('diff', 'show')
         ignore_whitespace = request.GET.get('ignorews') == '1'
         line_context = request.GET.get('context', 3)
         try:
             c.scm_type = c.rhodecode_repo.alias
             c.changeset = c.rhodecode_repo.get_changeset(revision)
         except RepositoryError:
             log.error(traceback.format_exc())
             return redirect(url('home'))
         else:
             try:
                 c.changeset_parent = c.changeset.parents[0]
             except IndexError:
                 c.changeset_parent = None
             c.changes = []
             for node in c.changeset.added:
                 filenode_old = FileNode(node.path, '')
                 if filenode_old.is_binary or node.is_binary:
                     diff = _('binary file') + '\n'
                 else:
                     f_gitdiff = diffs.get_gitdiff(filenode_old, node,
                                            ignore_whitespace=ignore_whitespace,
                                            context=line_context)
                     diff = diffs.DiffProcessor(f_gitdiff,
                                                 format='gitdiff').raw_diff()
                 cs1 = None
                 cs2 = node.changeset.raw_id
                 c.changes.append(('added', node, diff, cs1, cs2))
             for node in c.changeset.changed:
                 filenode_old = c.changeset_parent.get_node(node.path)
                 if filenode_old.is_binary or node.is_binary:
                     diff = _('binary file')

rhodecode/controllers/pullrequests.py

➞

Show inline comments

 # -*- coding: utf-8 -*-
 """
     rhodecode.controllers.pullrequests
     ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
     pull requests controller for rhodecode for initializing pull requests
     :created_on: May 7, 2012
     :author: marcink
     :copyright: (C) 2010-2012 Marcin Kuzminski <marcin@python-works.com>
     :license: GPLv3, see COPYING for more details.
 """
 # 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/>.
 import logging
 import traceback
 import binascii
 from webob.exc import HTTPNotFound
 from pylons import request, response, session, tmpl_context as c, url
 from pylons.controllers.util import abort, redirect
 from pylons.i18n.translation import _
 from rhodecode.lib.base import BaseRepoController, render
 from rhodecode.lib.auth import LoginRequired, HasRepoPermissionAnyDecorator
 from rhodecode.lib import helpers as h
 from rhodecode.model.db import User, PullRequest
 from rhodecode.lib import diffs
 from rhodecode.model.db import User, PullRequest, Repository, ChangesetStatus
 from rhodecode.model.pull_request import PullRequestModel
 from rhodecode.model.meta import Session
 from rhodecode.model.repo import RepoModel
 from rhodecode.model.comment import ChangesetCommentsModel
 from rhodecode.model.changeset_status import ChangesetStatusModel
 log = logging.getLogger(__name__)
 class PullrequestsController(BaseRepoController):
     @LoginRequired()
     @HasRepoPermissionAnyDecorator('repository.read', 'repository.write',
                                    'repository.admin')
     def __before__(self):
         super(PullrequestsController, self).__before__()
     def _get_repo_refs(self, repo):
         hist_l = []
         branches_group = ([('branch:' + k, k) for k in repo.branches.keys()],
                           _("Branches"))
         bookmarks_group = ([('book:' + k, k) for k in repo.bookmarks.keys()],
                            _("Bookmarks"))
         tags_group = ([('tag:' + k, k) for k in repo.tags.keys()],
                       _("Tags"))
         branches_group = ([('branch:%s:%s' % (k, v), k) for
                          k, v in repo.branches.iteritems()], _("Branches"))
         bookmarks_group = ([('book:%s:%s' % (k, v), k) for
                          k, v in repo.bookmarks.iteritems()], _("Bookmarks"))
         tags_group = ([('tag:%s:%s' % (k, v), k) for
                          k, v in repo.tags.iteritems()], _("Tags"))
         hist_l.append(bookmarks_group)
         hist_l.append(branches_group)
         hist_l.append(tags_group)
         return hist_l
     def show_all(self, repo_name):
         c.pull_requests = PullRequestModel().get_all(repo_name)
         c.repo_name = repo_name
         return render('/pullrequests/pullrequest_show_all.html')
     def index(self):
         org_repo = c.rhodecode_db_repo
         c.org_refs = self._get_repo_refs(c.rhodecode_repo)
         c.org_repos = []
         c.other_repos = []
         c.org_repos.append((org_repo.repo_name, '%s/%s' % (
                                 org_repo.user.username, c.repo_name))
+                           )
         c.other_refs = c.org_refs
         c.other_repos.extend(c.org_repos)
         c.default_pull_request = org_repo.repo_name
         #gather forks and add to this list
         for fork in org_repo.forks:
             c.other_repos.append((fork.repo_name, '%s/%s' % (
                                     fork.user.username, fork.repo_name))
+                                 )
         #add parents of this fork also
         if org_repo.parent:
             c.default_pull_request = org_repo.parent.repo_name
             c.other_repos.append((org_repo.parent.repo_name, '%s/%s' % (
                                         org_repo.parent.user.username,
                                         org_repo.parent.repo_name))
+                                     )
         #TODO: maybe the owner should be default ?
         c.review_members = []
         c.available_members = []
         for u in User.query().filter(User.username != 'default').all():
             uname = u.username
             if org_repo.user == u:
                 uname = _('%s (owner)' % u.username)
                 # auto add owner to pull-request recipients
                 c.review_members.append([u.user_id, uname])
             c.available_members.append([u.user_id, uname])
         return render('/pullrequests/pullrequest.html')
     def create(self, repo_name):
         req_p = request.POST
         org_repo = req_p['org_repo']
         org_ref = req_p['org_ref']
         other_repo = req_p['other_repo']
         other_ref = req_p['other_ref']
         revisions = req_p.getall('revisions')
         reviewers = req_p.getall('review_members')
         #TODO: wrap this into a FORM !!!
         title = req_p['pullrequest_title']
         description = req_p['pullrequest_desc']
         try:
             model = PullRequestModel()
             model.create(self.rhodecode_user.user_id, org_repo,
                          org_ref, other_repo, other_ref, revisions,
                          reviewers, title, description)
             Session.commit()
             h.flash(_('Pull request send'), category='success')
         except Exception:
             raise
             h.flash(_('Error occured during sending pull request'),
                     category='error')
             log.error(traceback.format_exc())
         return redirect(url('changelog_home', repo_name=repo_name))
     def _get_changesets(self, org_repo, org_ref, other_repo, other_ref, tmp):
         changesets = []
         #case two independent repos
         if org_repo != other_repo:
             common, incoming, rheads = tmp
             if not incoming:
                 revs = []
             else:
                 revs = org_repo._repo.changelog.findmissing(common, rheads)
             for cs in reversed(map(binascii.hexlify, revs)):
                 changesets.append(org_repo.get_changeset(cs))
         else:
             revs = ['ancestors(%s) and not ancestors(%s)' % (org_ref[1],
                                                              other_ref[1])]
             from mercurial import scmutil
             out = scmutil.revrange(org_repo._repo, revs)
             for cs in reversed(out):
                 changesets.append(org_repo.get_changeset(cs))
         return changesets
     def _get_discovery(self, org_repo, org_ref, other_repo, other_ref):
         from mercurial import discovery
         other = org_repo._repo
         repo = other_repo._repo
         tip = other[org_ref[1]]
         log.debug('Doing discovery for %s@%s vs %s@%s' % (
                         org_repo, org_ref, other_repo, other_ref)
+        )
         log.debug('Filter heads are %s[%s]' % (tip, org_ref[1]))
         tmp = discovery.findcommonincoming(
                   repo=repo,  # other_repo we check for incoming
                   remote=other,  # org_repo source for incoming
                   heads=[tip.node()],
                   force=False
+        )
         return tmp
     def _compare(self, pull_request):
         org_repo = pull_request.org_repo
         org_ref_type, org_ref_, org_ref = pull_request.org_ref.split(':')
         other_repo = pull_request.other_repo
         other_ref_type, other_ref, other_ref_ = pull_request.other_ref.split(':')
         org_ref = (org_ref_type, org_ref)
         other_ref = (other_ref_type, other_ref)
         c.org_repo = org_repo
         c.other_repo = other_repo
         discovery_data = self._get_discovery(org_repo.scm_instance,
                                            org_ref,
                                            other_repo.scm_instance,
                                            other_ref)
         c.cs_ranges = self._get_changesets(org_repo.scm_instance,
                                            org_ref,
                                            other_repo.scm_instance,
                                            other_ref,
                                            discovery_data)
         c.statuses = c.rhodecode_db_repo.statuses([x.raw_id for x in
                                                    c.cs_ranges])
         # defines that we need hidden inputs with changesets
         c.as_form = request.GET.get('as_form', False)
         if request.environ.get('HTTP_X_PARTIAL_XHR'):
             return render('compare/compare_cs.html')
         c.org_ref = org_ref[1]
         c.other_ref = other_ref[1]
         # diff needs to have swapped org with other to generate proper diff
         _diff = diffs.differ(other_repo, other_ref, org_repo, org_ref,
                              discovery_data)
         diff_processor = diffs.DiffProcessor(_diff, format='gitdiff')
         _parsed = diff_processor.prepare()
         c.files = []
         c.changes = {}
         for f in _parsed:
             fid = h.FID('', f['filename'])
             c.files.append([fid, f['operation'], f['filename'], f['stats']])
             diff = diff_processor.as_html(enable_comments=False, diff_lines=[f])
             c.changes[fid] = [f['operation'], f['filename'], diff]
     def show(self, repo_name, pull_request_id):
         repo_model = RepoModel()
         c.users_array = repo_model.get_users_js()
         c.users_groups_array = repo_model.get_users_groups_js()
         c.pull_request = PullRequest.get(pull_request_id)
         ##TODO: need more generic solution
         self._compare(c.pull_request)
         # inline comments
         c.inline_cnt = 0
         c.inline_comments = ChangesetCommentsModel()\
                             .get_inline_comments(c.rhodecode_db_repo.repo_id,
                                                  pull_request=pull_request_id)
         # count inline comments
         for __, lines in c.inline_comments:
             for comments in lines.values():
                 c.inline_cnt += len(comments)
         # comments
         c.comments = ChangesetCommentsModel()\
                           .get_comments(c.rhodecode_db_repo.repo_id,
                                         pull_request=pull_request_id)
         # changeset(pull-request) statuse
         c.current_changeset_status = ChangesetStatusModel()\
                               .get_status(c.rhodecode_db_repo.repo_id,
                                           pull_request=pull_request_id)
         c.changeset_statuses = ChangesetStatus.STATUSES
         return render('/pullrequests/pullrequest_show.html')

rhodecode/lib/base.py

➞

Show inline comments

@@ @@ -159,59 +159,61 @@ class BaseController(WSGIController): @@
     def __call__(self, environ, start_response):
         """Invoke the Controller"""
         # WSGIController.__call__ dispatches to the Controller method
         # the request is routed to. This routing information is
         # available in environ['pylons.routes_dict']
         start = time.time()
         try:
             self.ip_addr = _get_ip_addr(environ)
             # make sure that we update permissions each time we call controller
             api_key = request.GET.get('api_key')
             cookie_store = CookieStoreWrapper(session.get('rhodecode_user'))
             user_id = cookie_store.get('user_id', None)
             username = get_container_username(environ, config)
             auth_user = AuthUser(user_id, api_key, username)
             request.user = auth_user
             self.rhodecode_user = c.rhodecode_user = auth_user
             if not self.rhodecode_user.is_authenticated and \
                        self.rhodecode_user.user_id is not None:
                 self.rhodecode_user.set_authenticated(
                     cookie_store.get('is_authenticated')
+                )
             log.info('User: %s accessed %s' % (
                 auth_user, safe_unicode(environ.get('PATH_INFO')))
+            )
             return WSGIController.__call__(self, environ, start_response)
         finally:
             log.info('Request to %s time: %.3fs' % (
                 safe_unicode(environ.get('PATH_INFO')), time.time() - start)
+            )
             meta.Session.remove()
 class BaseRepoController(BaseController):
     """
     Base class for controllers responsible for loading all needed data for
     repository loaded items are
     c.rhodecode_repo: instance of scm repository
     c.rhodecode_db_repo: instance of db
     c.repository_followers: number of followers
     c.repository_forks: number of forks
     """
     def __before__(self):
         super(BaseRepoController, self).__before__()
         if c.repo_name:
             c.rhodecode_db_repo = Repository.get_by_repo_name(c.repo_name)
+            dbr = c.rhodecode_db_repo = Repository.get_by_repo_name(c.repo_name)
             c.rhodecode_repo = c.rhodecode_db_repo.scm_instance
             if c.rhodecode_repo is None:
                 log.error('%s this repository is present in database but it '
                           'cannot be created as an scm instance', c.repo_name)
                 redirect(url('home'))
             c.repository_followers = self.scm_model.get_followers(c.repo_name)
             c.repository_forks = self.scm_model.get_forks(c.repo_name)
             # some globals counter for menu
             c.repository_followers = self.scm_model.get_followers(dbr)
             c.repository_forks = self.scm_model.get_forks(dbr)
             c.repository_pull_requests = self.scm_model.get_pull_requests(dbr)
@@ \ No newline at end of file @@

rhodecode/model/changeset_status.py

➞

Show inline comments

 # -*- coding: utf-8 -*-
 """
     rhodecode.model.changeset_status
     ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
     :created_on: Apr 30, 2012
     :author: marcink
     :copyright: (C) 2011-2012 Marcin Kuzminski <marcin@python-works.com>
     :license: GPLv3, see COPYING for more details.
 """
 # 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/>.
 import logging
 from rhodecode.model import BaseModel
 from rhodecode.model.db import ChangesetStatus
+from rhodecode.model.db import ChangesetStatus, PullRequest
 log = logging.getLogger(__name__)
 class ChangesetStatusModel(BaseModel):
     def __get_changeset_status(self, changeset_status):
         return self._get_instance(ChangesetStatus, changeset_status)
     def get_status(self, repo, revision):
     def __get_pull_request(self, pull_request):
         return self._get_instance(PullRequest, pull_request)
     def get_status(self, repo, revision=None, pull_request=None):
         """
         Returns status of changeset for given revision and version 0
         versioning makes a history of statuses, and version == 0 is always the
         current one
         Returns latest status of changeset for given revision or for given
         pull request. Statuses are versioned inside a table itself and
         version == 0 is always the current one
         :param repo:
         :type repo:
         :param revision: 40char hash
+        :param revision: 40char hash or None
         :type revision: str
         :param pull_request: pull_request reference
         :type:
         """
         repo = self._get_repo(repo)
-        status = ChangesetStatus.query()\
+        q = ChangesetStatus.query()\
             .filter(ChangesetStatus.repo == repo)\
             .filter(ChangesetStatus.revision == revision)\
             .filter(ChangesetStatus.version == 0).scalar()
             .filter(ChangesetStatus.version == 0)
         if revision:
             q = q.filter(ChangesetStatus.revision == revision)
         elif pull_request:
             pull_request = self.__get_pull_request(pull_request)
             q = q.filter(ChangesetStatus.pull_request == pull_request)
         else:
             raise Exception('Please specify revision or pull_request')
         status = q.scalar()
         status = status.status if status else status
         st = status or ChangesetStatus.DEFAULT
         return str(st)
     def set_status(self, repo, revision, status, user, comment):
         """
         Creates new status for changeset or updates the old ones bumping their
         version, leaving the current status at
         :param repo:
         :type repo:
         :param revision:
         :type revision:
         :param status:
         :type status:
         :param user:
         :type user:
         :param comment:
         :type comment:
         """
         repo = self._get_repo(repo)
         cur_statuses = ChangesetStatus.query()\
             .filter(ChangesetStatus.repo == repo)\
             .filter(ChangesetStatus.revision == revision)\
             .all()
         if cur_statuses:
             for st in cur_statuses:
                 st.version += 1
                 self.sa.add(st)
         new_status = ChangesetStatus()
         new_status.author = self._get_user(user)
         new_status.repo = self._get_repo(repo)
         new_status.status = status
         new_status.revision = revision
         new_status.comment = comment
         self.sa.add(new_status)
         return new_status

rhodecode/model/comment.py

➞

Show inline comments

 # -*- coding: utf-8 -*-
 """
     rhodecode.model.comment
     ~~~~~~~~~~~~~~~~~~~~~~~
     comments model for RhodeCode
     :created_on: Nov 11, 2011
     :author: marcink
     :copyright: (C) 2011-2012 Marcin Kuzminski <marcin@python-works.com>
     :license: GPLv3, see COPYING for more details.
 """
 # 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/>.
 import logging
 import traceback
 from pylons.i18n.translation import _
 from sqlalchemy.util.compat import defaultdict
 from rhodecode.lib.utils2 import extract_mentioned_users, safe_unicode
 from rhodecode.lib import helpers as h
 from rhodecode.model import BaseModel
 from rhodecode.model.db import ChangesetComment, User, Repository, Notification
 from rhodecode.model.db import ChangesetComment, User, Repository, \
     Notification, PullRequest
 from rhodecode.model.notification import NotificationModel
 log = logging.getLogger(__name__)
 class ChangesetCommentsModel(BaseModel):
     def __get_changeset_comment(self, changeset_comment):
         return self._get_instance(ChangesetComment, changeset_comment)
     def __get_pull_request(self, pull_request):
         return self._get_instance(PullRequest, pull_request)
     def _extract_mentions(self, s):
         user_objects = []
         for username in extract_mentioned_users(s):
             user_obj = User.get_by_username(username, case_insensitive=True)
             if user_obj:
                 user_objects.append(user_obj)
         return user_objects
     def create(self, text, repo_id, user_id, revision, f_path=None,
                line_no=None, status_change=None):
         """
         Creates new comment for changeset. IF status_change is not none
         this comment is associated with a status change of changeset
         :param text:
         :param repo_id:
         :param user_id:
         :param revision:
         :param f_path:
         :param line_no:
         :param status_change:
         """
         if text:
             repo = Repository.get(repo_id)
             cs = repo.scm_instance.get_changeset(revision)
             desc = "%s - %s" % (cs.short_id, h.shorter(cs.message, 256))
             author_email = cs.author_email
             comment = ChangesetComment()
             comment.repo = repo
             comment.user_id = user_id
             comment.revision = revision
             comment.text = text
             comment.f_path = f_path
             comment.line_no = line_no
             self.sa.add(comment)
             self.sa.flush()
             # make notification
             line = ''
             if line_no:
                 line = _('on line %s') % line_no
             subj = safe_unicode(
                 h.link_to('Re commit: %(commit_desc)s %(line)s' % \
                           {'commit_desc': desc, 'line': line},
                           h.url('changeset_home', repo_name=repo.repo_name,
                                 revision=revision,
                                 anchor='comment-%s' % comment.comment_id,
                                 qualified=True,
+                          )
+                )
+            )
             body = text
             # get the current participants of this changeset
             recipients = ChangesetComment.get_users(revision=revision)
             # add changeset author if it's in rhodecode system
             recipients += [User.get_by_email(author_email)]
             # create notification objects, and emails
             NotificationModel().create(
               created_by=user_id, subject=subj, body=body,
               recipients=recipients, type_=Notification.TYPE_CHANGESET_COMMENT,
               email_kwargs={'status_change': status_change}
+            )
             mention_recipients = set(self._extract_mentions(body))\
                                     .difference(recipients)
             if mention_recipients:
                 subj = _('[Mention]') + ' ' + subj
                 NotificationModel().create(
                     created_by=user_id, subject=subj, body=body,
                     recipients=mention_recipients,
                     type_=Notification.TYPE_CHANGESET_COMMENT,
                     email_kwargs={'status_change': status_change}
+                )
             return comment
     def delete(self, comment):
         """
         Deletes given comment
         :param comment_id:
         """
         comment = self.__get_changeset_comment(comment)
         self.sa.delete(comment)
         return comment
-    def get_comments(self, repo_id, revision=None, pull_request_id=None):
+    def get_comments(self, repo_id, revision=None, pull_request=None):
         """
         Get's main comments based on revision or pull_request_id
         :param repo_id:
         :type repo_id:
         :param revision:
         :type revision:
         :param pull_request_id:
         :type pull_request_id:
         :param pull_request:
         :type pull_request:
         """
         q = ChangesetComment.query()\
                 .filter(ChangesetComment.repo_id == repo_id)\
                 .filter(ChangesetComment.line_no == None)\
                 .filter(ChangesetComment.f_path == None)
         if revision:
             q = q.filter(ChangesetComment.revision == revision)
         elif pull_request_id:
             q = q.filter(ChangesetComment.pull_request_id == pull_request_id)
         elif pull_request:
             pull_request = self.__get_pull_request(pull_request)
             q = q.filter(ChangesetComment.pull_request == pull_request)
         else:
-            raise Exception('Please specify revision or pull_request_id')
+            raise Exception('Please specify revision or pull_request')
         return q.all()
-    def get_inline_comments(self, repo_id, revision=None, pull_request_id=None):
+    def get_inline_comments(self, repo_id, revision=None, pull_request=None):
         q = self.sa.query(ChangesetComment)\
             .filter(ChangesetComment.repo_id == repo_id)\
             .filter(ChangesetComment.line_no != None)\
             .filter(ChangesetComment.f_path != None)\
             .order_by(ChangesetComment.comment_id.asc())\
         if revision:
             q = q.filter(ChangesetComment.revision == revision)
         elif pull_request_id:
             q = q.filter(ChangesetComment.pull_request_id == pull_request_id)
         elif pull_request:
             pull_request = self.__get_pull_request(pull_request)
             q = q.filter(ChangesetComment.pull_request == pull_request)
         else:
             raise Exception('Please specify revision or pull_request_id')
         comments = q.all()
         paths = defaultdict(lambda: defaultdict(list))
         for co in comments:
             paths[co.f_path][co.line_no].append(co)
         return paths.items()

rhodecode/model/db.py

➞

Show inline comments

@@ @@ -1277,185 +1277,190 @@ class CacheInvalidation(Base, BaseModel) @@
         inv_obj = cls.get_by_key(key)
         inv_obj.cache_active = True
         Session.add(inv_obj)
         Session.commit()
     @classmethod
     def get_cache_map(cls):
         class cachemapdict(dict):
             def __init__(self, *args, **kwargs):
                 fixkey = kwargs.get('fixkey')
                 if fixkey:
                     del kwargs['fixkey']
                 self.fixkey = fixkey
                 super(cachemapdict, self).__init__(*args, **kwargs)
             def __getattr__(self, name):
                 key = name
                 if self.fixkey:
                     key, _prefix, _org_key = cls._get_key(key)
                 if key in self.__dict__:
                     return self.__dict__[key]
                 else:
                     return self[key]
             def __getitem__(self, key):
                 if self.fixkey:
                     key, _prefix, _org_key = cls._get_key(key)
                 try:
                     return super(cachemapdict, self).__getitem__(key)
                 except KeyError:
                     return
         cache_map = cachemapdict(fixkey=True)
         for obj in cls.query().all():
             cache_map[obj.cache_key] = cachemapdict(obj.get_dict())
         return cache_map
 class ChangesetComment(Base, BaseModel):
     __tablename__ = 'changeset_comments'
     __table_args__ = (
         {'extend_existing': True, 'mysql_engine': 'InnoDB',
          'mysql_charset': 'utf8'},
+    )
     comment_id = Column('comment_id', Integer(), nullable=False, primary_key=True)
     repo_id = Column('repo_id', Integer(), ForeignKey('repositories.repo_id'), nullable=False)
     revision = Column('revision', String(40), nullable=False)
     revision = Column('revision', String(40), nullable=True)
     pull_request_id = Column("pull_request_id", Integer(), ForeignKey('pull_requests.pull_request_id'), nullable=True)
     line_no = Column('line_no', Unicode(10), nullable=True)
     f_path = Column('f_path', Unicode(1000), nullable=True)
     user_id = Column('user_id', Integer(), ForeignKey('users.user_id'), nullable=False)
     text = Column('text', Unicode(25000), nullable=False)
     modified_at = Column('modified_at', DateTime(), nullable=False, default=datetime.datetime.now)
     author = relationship('User', lazy='joined')
     repo = relationship('Repository')
     status_change = relationship('ChangesetStatus', uselist=False)
     pull_request = relationship('PullRequest', lazy='joined')
     @classmethod
     def get_users(cls, revision):
         """
         Returns user associated with this changesetComment. ie those
         who actually commented
         :param cls:
         :param revision:
         """
         return Session.query(User)\
                 .filter(cls.revision == revision)\
                 .join(ChangesetComment.author).all()
 class ChangesetStatus(Base, BaseModel):
     __tablename__ = 'changeset_statuses'
     __table_args__ = (
         UniqueConstraint('repo_id', 'revision', 'version'),
         {'extend_existing': True, 'mysql_engine': 'InnoDB',
          'mysql_charset': 'utf8'}
+    )
     STATUSES = [
         ('not_reviewed', _("Not Reviewed")),  # (no icon) and default
         ('approved', _("Approved")),
         ('rejected', _("Rejected")),
         ('under_review', _("Under Review")),
+    ]
     DEFAULT = STATUSES[0][0]
     changeset_status_id = Column('changeset_status_id', Integer(), nullable=False, primary_key=True)
     repo_id = Column('repo_id', Integer(), ForeignKey('repositories.repo_id'), nullable=False)
     user_id = Column("user_id", Integer(), ForeignKey('users.user_id'), nullable=False, unique=None)
     revision = Column('revision', String(40), nullable=False)
     status = Column('status', String(128), nullable=False, default=DEFAULT)
     changeset_comment_id = Column('changeset_comment_id', Integer(), ForeignKey('changeset_comments.comment_id'))
     modified_at = Column('modified_at', DateTime(), nullable=False, default=datetime.datetime.now)
     version = Column('version', Integer(), nullable=False, default=0)
     pull_request_id = Column("pull_request_id", Integer(), ForeignKey('pull_requests.pull_request_id'), nullable=True)
     author = relationship('User', lazy='joined')
     repo = relationship('Repository')
     comment = relationship('ChangesetComment', lazy='joined')
     pull_request = relationship('PullRequest', lazy='joined')
     @classmethod
     def get_status_lbl(cls, value):
         return dict(cls.STATUSES).get(value)
     @property
     def status_lbl(self):
         return ChangesetStatus.get_status_lbl(self.status)
 class PullRequest(Base, BaseModel):
     __tablename__ = 'pull_requests'
     __table_args__ = (
         {'extend_existing': True, 'mysql_engine': 'InnoDB',
          'mysql_charset': 'utf8'},
+    )
     pull_request_id = Column('pull_request_id', Integer(), nullable=False, primary_key=True)
     title = Column('title', Unicode(256), nullable=True)
     description = Column('description', Unicode(10240), nullable=True)
     created_on = Column('created_on', DateTime(timezone=False), nullable=False, default=datetime.datetime.now)
     user_id = Column("user_id", Integer(), ForeignKey('users.user_id'), nullable=False, unique=None)
     _revisions = Column('revisions', UnicodeText(20500))  # 500 revisions max
     org_repo_id = Column('org_repo_id', Integer(), ForeignKey('repositories.repo_id'), nullable=False)
     org_ref = Column('org_ref', Unicode(256), nullable=False)
     other_repo_id = Column('other_repo_id', Integer(), ForeignKey('repositories.repo_id'), nullable=False)
     other_ref = Column('other_ref', Unicode(256), nullable=False)
     @hybrid_property
     def revisions(self):
         return self._revisions.split(':')
     @revisions.setter
     def revisions(self, val):
         self._revisions = ':'.join(val)
     author = relationship('User', lazy='joined')
     reviewers = relationship('PullRequestReviewers')
     org_repo = relationship('Repository', primaryjoin='PullRequest.org_repo_id==Repository.repo_id')
     other_repo = relationship('Repository', primaryjoin='PullRequest.other_repo_id==Repository.repo_id')
     def __json__(self):
         return dict(
           revisions=self.revisions
+        )
 class PullRequestReviewers(Base, BaseModel):
     __tablename__ = 'pull_request_reviewers'
     __table_args__ = (
         {'extend_existing': True, 'mysql_engine': 'InnoDB',
          'mysql_charset': 'utf8'},
+    )
     def __init__(self, user=None, pull_request=None):
         self.user = user
         self.pull_request = pull_request
     pull_requests_reviewers_id = Column('pull_requests_reviewers_id', Integer(), nullable=False, primary_key=True)
     pull_request_id = Column("pull_request_id", Integer(), ForeignKey('pull_requests.pull_request_id'), nullable=False)
     user_id = Column("user_id", Integer(), ForeignKey('users.user_id'), nullable=True)
     user = relationship('User')
     pull_request = relationship('PullRequest')
 class Notification(Base, BaseModel):
     __tablename__ = 'notifications'
     __table_args__ = (
         {'extend_existing': True, 'mysql_engine': 'InnoDB',
          'mysql_charset': 'utf8'},
+    )
     TYPE_CHANGESET_COMMENT = u'cs_comment'
     TYPE_MESSAGE = u'message'
     TYPE_MENTION = u'mention'
     TYPE_REGISTRATION = u'registration'
     TYPE_PULL_REQUEST = u'pull_request'
     notification_id = Column('notification_id', Integer(), nullable=False, primary_key=True)
     subject = Column('subject', Unicode(512), nullable=True)
     body = Column('body', Unicode(50000), nullable=True)
     created_by = Column("created_by", Integer(), ForeignKey('users.user_id'), nullable=True)
     created_on = Column('created_on', DateTime(timezone=False), nullable=False, default=datetime.datetime.now)
     type_ = Column('type', Unicode(256))

rhodecode/model/pull_request.py

➞

Show inline comments

 # -*- coding: utf-8 -*-
 """
     rhodecode.model.pull_reuquest
     ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
     pull request model for RhodeCode
     :created_on: Jun 6, 2012
     :author: marcink
     :copyright: (C) 2012-2012 Marcin Kuzminski <marcin@python-works.com>
     :license: GPLv3, see COPYING for more details.
 """
 # 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/>.
 import logging
 from pylons.i18n.translation import _
 from rhodecode.lib import helpers as h
 from rhodecode.model import BaseModel
 from rhodecode.model.db import PullRequest, PullRequestReviewers, Notification
 from rhodecode.model.notification import NotificationModel
 from rhodecode.lib.utils2 import safe_unicode
 log = logging.getLogger(__name__)
 class PullRequestModel(BaseModel):
     def get_all(self, repo):
         repo = self._get_repo(repo)
         return PullRequest.query().filter(PullRequest.other_repo == repo).all()
     def create(self, created_by, org_repo, org_ref, other_repo,
                other_ref, revisions, reviewers, title, description=None):
         created_by_user = self._get_user(created_by)
         new = PullRequest()
         new.org_repo = self._get_repo(org_repo)
         new.org_ref = org_ref
         new.other_repo = self._get_repo(other_repo)
         new.other_ref = other_ref
         new.revisions = revisions
         new.title = title
         new.description = description
+        new.author = created_by_user
         self.sa.add(new)
         #members
         for member in reviewers:
             _usr = self._get_user(member)
             reviewer = PullRequestReviewers(_usr, new)
             self.sa.add(reviewer)
         #notification to reviewers
         notif = NotificationModel()
-        created_by_user = self._get_user(created_by)
         subject = safe_unicode(
             h.link_to(
               _('%(user)s wants you to review pull request #%(pr_id)s') % \
                 {'user': created_by_user.username,
                  'pr_id': new.pull_request_id},
               h.url('pullrequest_show', repo_name=other_repo,
                     pull_request_id=new.pull_request_id,
                     qualified=True,
+              )
+            )
+        )
         body = description
         notif.create(created_by=created_by, subject=subject, body=body,
                      recipients=reviewers,
                      type_=Notification.TYPE_PULL_REQUEST,)
         return new

rhodecode/model/scm.py

➞

Show inline comments

 # -*- coding: utf-8 -*-
 """
     rhodecode.model.scm
     ~~~~~~~~~~~~~~~~~~~
     Scm model for RhodeCode
     :created_on: Apr 9, 2010
     :author: marcink
     :copyright: (C) 2010-2012 Marcin Kuzminski <marcin@python-works.com>
     :license: GPLv3, see COPYING for more details.
 """
 # 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/>.
 import os
 import time
 import traceback
 import logging
 import cStringIO
 from sqlalchemy import func
 from rhodecode.lib.vcs import get_backend
 from rhodecode.lib.vcs.exceptions import RepositoryError
 from rhodecode.lib.vcs.utils.lazy import LazyProperty
 from rhodecode.lib.vcs.nodes import FileNode
 from rhodecode import BACKENDS
 from rhodecode.lib import helpers as h
 from rhodecode.lib.utils2 import safe_str, safe_unicode
 from rhodecode.lib.auth import HasRepoPermissionAny, HasReposGroupPermissionAny
 from rhodecode.lib.utils import get_repos as get_filesystem_repos, make_ui, \
     action_logger, EmptyChangeset, REMOVED_REPO_PAT
 from rhodecode.model import BaseModel
 from rhodecode.model.db import Repository, RhodeCodeUi, CacheInvalidation, \
     UserFollowing, UserLog, User, RepoGroup
+    UserFollowing, UserLog, User, RepoGroup, PullRequest
 log = logging.getLogger(__name__)
 class UserTemp(object):
     def __init__(self, user_id):
         self.user_id = user_id
     def __repr__(self):
         return "<%s('id:%s')>" % (self.__class__.__name__, self.user_id)
 class RepoTemp(object):
     def __init__(self, repo_id):
         self.repo_id = repo_id
     def __repr__(self):
         return "<%s('id:%s')>" % (self.__class__.__name__, self.repo_id)
 class CachedRepoList(object):
     def __init__(self, db_repo_list, repos_path, order_by=None):
         self.db_repo_list = db_repo_list
         self.repos_path = repos_path
         self.order_by = order_by
         self.reversed = (order_by or '').startswith('-')
     def __len__(self):
         return len(self.db_repo_list)
     def __repr__(self):
         return '<%s (%s)>' % (self.__class__.__name__, self.__len__())
     def __iter__(self):
         # pre-propagated cache_map to save executing select statements
         # for each repo
         cache_map = CacheInvalidation.get_cache_map()
         for dbr in self.db_repo_list:
             scmr = dbr.scm_instance_cached(cache_map)
             # check permission at this level
             if not HasRepoPermissionAny(
                 'repository.read', 'repository.write', 'repository.admin'
             )(dbr.repo_name, 'get repo check'):
                 continue
             if scmr is None:
@@ @@ -275,109 +275,111 @@ class ScmModel(BaseModel): @@
             action_logger(UserTemp(user_id),
                           'started_following_repo',
                           RepoTemp(follow_repo_id))
         except:
             log.error(traceback.format_exc())
             raise
     def toggle_following_user(self, follow_user_id, user_id):
         f = self.sa.query(UserFollowing)\
             .filter(UserFollowing.follows_user_id == follow_user_id)\
             .filter(UserFollowing.user_id == user_id).scalar()
         if f is not None:
             try:
                 self.sa.delete(f)
                 return
             except:
                 log.error(traceback.format_exc())
                 raise
         try:
             f = UserFollowing()
             f.user_id = user_id
             f.follows_user_id = follow_user_id
             self.sa.add(f)
         except:
             log.error(traceback.format_exc())
             raise
     def is_following_repo(self, repo_name, user_id, cache=False):
         r = self.sa.query(Repository)\
             .filter(Repository.repo_name == repo_name).scalar()
         f = self.sa.query(UserFollowing)\
             .filter(UserFollowing.follows_repository == r)\
             .filter(UserFollowing.user_id == user_id).scalar()
         return f is not None
     def is_following_user(self, username, user_id, cache=False):
         u = User.get_by_username(username)
         f = self.sa.query(UserFollowing)\
             .filter(UserFollowing.follows_user == u)\
             .filter(UserFollowing.user_id == user_id).scalar()
         return f is not None
     def get_followers(self, repo_id):
         if not isinstance(repo_id, int):
             repo_id = getattr(Repository.get_by_repo_name(repo_id), 'repo_id')
     def get_followers(self, repo):
         repo = self._get_repo(repo)
         return self.sa.query(UserFollowing)\
-                .filter(UserFollowing.follows_repo_id == repo_id).count()
+                .filter(UserFollowing.follows_repository == repo).count()
     def get_forks(self, repo_id):
         if not isinstance(repo_id, int):
             repo_id = getattr(Repository.get_by_repo_name(repo_id), 'repo_id')
     def get_forks(self, repo):
         repo = self._get_repo(repo)
         return self.sa.query(Repository)\
                 .filter(Repository.fork == repo).count()
         return self.sa.query(Repository)\
                 .filter(Repository.fork_id == repo_id).count()
     def get_pull_requests(self, repo):
         repo = self._get_repo(repo)
         return self.sa.query(PullRequest)\
                 .filter(PullRequest.other_repo == repo).count()
     def mark_as_fork(self, repo, fork, user):
         repo = self.__get_repo(repo)
         fork = self.__get_repo(fork)
         repo.fork = fork
         self.sa.add(repo)
         return repo
     def pull_changes(self, repo_name, username):
         dbrepo = Repository.get_by_repo_name(repo_name)
         clone_uri = dbrepo.clone_uri
         if not clone_uri:
             raise Exception("This repository doesn't have a clone uri")
         repo = dbrepo.scm_instance
         try:
             extras = {
                 'ip': '',
                 'username': username,
                 'action': 'push_remote',
                 'repository': repo_name,
                 'scm': repo.alias,
+            }
             # inject ui extra param to log this action via push logger
             for k, v in extras.items():
                 repo._repo.ui.setconfig('rhodecode_extras', k, v)
             if repo.alias == 'git':
                 repo.fetch(clone_uri)
             else:
                 repo.pull(clone_uri)
             self.mark_for_invalidation(repo_name)
         except:
             log.error(traceback.format_exc())
             raise
     def commit_change(self, repo, repo_name, cs, user, author, message,
                       content, f_path):
         if repo.alias == 'hg':
             from rhodecode.lib.vcs.backends.hg import \
                 MercurialInMemoryChangeset as IMC
         elif repo.alias == 'git':
             from rhodecode.lib.vcs.backends.git import \
                 GitInMemoryChangeset as IMC
         # decoding here will force that we have proper encoded values
         # in any other case this will throw exceptions and deny commit

rhodecode/templates/base/base.html

➞

Show inline comments

@@ @@ -202,96 +202,104 @@ @@
                    %if h.HasRepoPermissionAll('repository.admin')(c.repo_name):
                      %if h.HasPermissionAll('hg.admin')('access settings on repository'):
                          <li>${h.link_to(_('settings'),h.url('edit_repo',repo_name=c.repo_name),class_='settings')}</li>
                      %else:
                          <li>${h.link_to(_('settings'),h.url('repo_settings_home',repo_name=c.repo_name),class_='settings')}</li>
                      %endif
                    %endif
                    	<li>${h.link_to(_('fork'),h.url('repo_fork_home',repo_name=c.repo_name),class_='fork')}</li>
                    	<li>${h.link_to(_('search'),h.url('search_repo',search_repo=c.repo_name),class_='search')}</li>
                     % if h.HasPermissionAll('hg.admin')('access admin main page'):
                      <li>
                        ${h.link_to(_('admin'),h.url('admin_home'),class_='admin')}
                         <%def name="admin_menu()">
                         <ul>
                             <li>${h.link_to(_('journal'),h.url('admin_home'),class_='journal')}</li>
                             <li>${h.link_to(_('repositories'),h.url('repos'),class_='repos')}</li>
                             <li>${h.link_to(_('repositories groups'),h.url('repos_groups'),class_='repos_groups')}</li>
                             <li>${h.link_to(_('users'),h.url('users'),class_='users')}</li>
                             <li>${h.link_to(_('users groups'),h.url('users_groups'),class_='groups')}</li>
                             <li>${h.link_to(_('permissions'),h.url('edit_permission',id='default'),class_='permissions')}</li>
                             <li>${h.link_to(_('ldap'),h.url('ldap_home'),class_='ldap')}</li>
                             <li class="last">${h.link_to(_('settings'),h.url('admin_settings'),class_='settings')}</li>
                         </ul>
                         </%def>
                         ${admin_menu()}
                      </li>
                     % endif
                    </ul>
                 </li>
                 <li>
                     <a class="menu_link" title="${_('Followers')}" href="${h.url('repo_followers_home',repo_name=c.repo_name)}">
                     <span class="icon_short">
                         <img src="${h.url('/images/icons/heart.png')}" alt="${_('Followers')}" />
                     </span>
                     <span id="current_followers_count" class="short">${c.repository_followers}</span>
                     </a>
                 </li>
                 <li>
                     <a class="menu_link" title="${_('Forks')}" href="${h.url('repo_forks_home',repo_name=c.repo_name)}">
                     <span class="icon_short">
                         <img src="${h.url('/images/icons/arrow_divide.png')}" alt="${_('Forks')}" />
                     </span>
                     <span class="short">${c.repository_forks}</span>
                     </a>
                 </li>
                 <li>
                     <a class="menu_link" title="${_('Pull requests')}" href="${h.url('pullrequest_show_all',repo_name=c.repo_name)}">
                     <span class="icon_short">
                         <img src="${h.url('/images/icons/arrow_join.png')}" alt="${_('Pull requests')}" />
                     </span>
                     <span class="short">${c.repository_pull_requests}</span>
                     </a>
                 </li>
                 ${usermenu()}
 	        </ul>
             <script type="text/javascript">
                YUE.on('repo_switcher','mouseover',function(){
                       function qfilter(){
                           var nodes = YUQ('ul#repo_switcher_list li a.repo_name');
                           var target = 'q_filter_rs';
                           var func = function(node){
                               return node.parentNode;
+                          }
                           q_filter(target,nodes,func);
+                      }
                    var loaded = YUD.hasClass('repo_switcher','loaded');
                    if(!loaded){
                        YUD.addClass('repo_switcher','loaded');
                        ypjax("${h.url('repo_switcher')}",'repo_switcher_list',
                            function(o){qfilter();},
                            function(o){YUD.removeClass('repo_switcher','loaded');}
                            ,null);
+                   }
                    return false;
                });
               YUE.on('branch_tag_switcher','mouseover',function(){
                  var loaded = YUD.hasClass('branch_tag_switcher','loaded');
                  if(!loaded){
                      YUD.addClass('branch_tag_switcher','loaded');
                      ypjax("${h.url('branch_tag_switcher',repo_name=c.repo_name)}",'switch_to_list',
                          function(o){},
                          function(o){YUD.removeClass('branch_tag_switcher','loaded');}
                          ,null);
+                 }
                  return false;
               });
             </script>
 		%else:
 		    ##ROOT MENU
             <ul id="quick">
                 <li>
                     <a class="menu_link" title="${_('Home')}"  href="${h.url('home')}">
                     <span class="icon">
                         <img src="${h.url('/images/icons/home_16.png')}" alt="${_('Home')}" />
                     </span>
                     <span>${_('Home')}</span>
                     </a>
                 </li>
                 %if c.rhodecode_user.username != 'default':
                  <li>

rhodecode/templates/pullrequests/pullrequest_show.html

➞

Show inline comments

 <%inherit file="/base/base.html"/>
 <%def name="title()">
     ${c.repo_name} ${_('Pull request #%s') % c.pull_request.pull_request_id}
 </%def>
 <%def name="breadcrumbs_links()">
     ${h.link_to(u'Home',h.url('/'))}
     &raquo;
     ${h.link_to(c.repo_name,h.url('changelog_home',repo_name=c.repo_name))}
     &raquo;
     ${_('Pull request #%s') % c.pull_request.pull_request_id}
 </%def>
 <%def name="main()">
 <div class="box">
     <!-- box / title -->
     <div class="title">
         ${self.breadcrumbs()}
     </div>
     pull request ${c.pull_request} overview...
     <h3>${_('Title')}: ${c.pull_request.title}</h3>
     <div class="changeset-status-container" style="float:left;padding:0px 20px 20px 20px">
         %if c.current_changeset_status:
           <div title="${_('Changeset status')}" class="changeset-status-lbl">[${h.changeset_status_lbl(c.current_changeset_status)}]</div>
           <div class="changeset-status-ico"><img src="${h.url('/images/icons/flag_status_%s.png' % c.current_changeset_status)}" /></div>
         %endif
     </div>
     <div style="padding:4px">
       <div>${h.fmt_date(c.pull_request.created_on)}</div>
     </div>
     ##DIFF
     <div class="table">
         <div id="body" class="diffblock">
             <div style="white-space:pre-wrap;padding:5px">${h.literal(c.pull_request.description)}</div>
         </div>
         <div id="changeset_compare_view_content">
             ##CS
             <div style="font-size:1.1em;font-weight: bold;clear:both;padding-top:10px">${_('Incoming changesets')}</div>
             <%include file="/compare/compare_cs.html" />
             ## FILES
             <div style="font-size:1.1em;font-weight: bold;clear:both;padding-top:10px">${_('Files affected')}</div>
             <div class="cs_files">
               %for fid, change, f, stat in c.files:
                   <div class="cs_${change}">
                     <div class="node">${h.link_to(h.safe_unicode(f),h.url.current(anchor=fid))}</div>
                     <div class="changes">${h.fancy_file_stats(stat)}</div>
                   </div>
               %endfor
             </div>
         </div>
     </div>
     <script>
     var _USERS_AC_DATA = ${c.users_array|n};
     var _GROUPS_AC_DATA = ${c.users_groups_array|n};
     </script>
     ## diff block
     <%namespace name="diff_block" file="/changeset/diff_block.html"/>
     %for fid, change, f, stat in c.files:
       ${diff_block.diff_block_simple([c.changes[fid]])}
     %endfor
     ## template for inline comment form
     <%namespace name="comment" file="/changeset/changeset_file_comment.html"/>
     ##${comment.comment_inline_form(c.changeset)}
     ## render comments main comments form and it status
     ##${comment.comments(h.url('pull_request_comment', repo_name=c.repo_name, pull_request_id=c.pull_request.pull_request_id),
     ##                   c.current_changeset_status)}
 </div>
 <script type="text/javascript">
 </script>
 </%def>

rhodecode/templates/pullrequests/pullrequest_show_all.html

➞

Show inline comments

@@ new file 100644 @@
 <%inherit file="/base/base.html"/>
 <%def name="title()">
     ${c.repo_name} ${_('All pull requests')}
 </%def>
 <%def name="breadcrumbs_links()">
     ${h.link_to(u'Home',h.url('/'))}
     &raquo;
     ${h.link_to(c.repo_name,h.url('changelog_home',repo_name=c.repo_name))}
     &raquo;
     ${_('All pull requests')}
 </%def>
 <%def name="main()">
 <div class="box">
     <!-- box / title -->
     <div class="title">
         ${self.breadcrumbs()}
     </div>
     %for pr in c.pull_requests:
         <a href="${h.url('pullrequest_show',repo_name=c.repo_name,pull_request_id=pr.pull_request_id)}">#${pr.pull_request_id}</a>
     %endfor
 </div>
 <script type="text/javascript"></script>
 </%def>

0 comments (0 inline, 0 general)