Added dynamic data loading for other repo we open pull request against

- fixed notification emails, now with link to comment or status change in given pull request

rhodecode/controllers/changeset.py

@@ -1,428 +1,428 b''
 # -*- coding: utf-8 -*-
 """
     rhodecode.controllers.changeset
     ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
     changeset controller for pylons showoing changes beetween
     revisions
 
     :created_on: Apr 25, 2010
     :author: marcink
     :copyright: (C) 2010-2012 Marcin Kuzminski <[e-mail]>
     :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 collections import defaultdict
 from webob.exc import HTTPForbidden
 
 from pylons import tmpl_context as c, url, request, response
 from pylons.i18n.translation import _
 from pylons.controllers.util import redirect
 from pylons.decorators import jsonify
 
 from rhodecode.lib.vcs.exceptions import RepositoryError, ChangesetError, \
     ChangesetDoesNotExistError
 from rhodecode.lib.vcs.nodes import FileNode
 
 import rhodecode.lib.helpers as h
 from rhodecode.lib.auth import LoginRequired, HasRepoPermissionAnyDecorator
 from rhodecode.lib.base import BaseRepoController, render
 from rhodecode.lib.utils import EmptyChangeset, action_logger
 from rhodecode.lib.compat import OrderedDict
 from rhodecode.lib import diffs
 from rhodecode.model.db import ChangesetComment, ChangesetStatus
 from rhodecode.model.comment import ChangesetCommentsModel
 from rhodecode.model.changeset_status import ChangesetStatusModel
 from rhodecode.model.meta import Session
 from rhodecode.lib.diffs import wrapped_diff
 from rhodecode.model.repo import RepoModel
 
 log = logging.getLogger(__name__)
 
 
 def _update_with_GET(params, GET):
     for k in ['diff1', 'diff2', 'diff']:
         params[k] += GET.getall(k)
 
 
 def anchor_url(revision, path, GET):
     fid = h.FID(revision, path)
     return h.url.current(anchor=fid, **dict(GET))
 
 
 def get_ignore_ws(fid, GET):
     ig_ws_global = GET.get('ignorews')
     ig_ws = filter(lambda k: k.startswith('WS'), GET.getall(fid))
     if ig_ws:
         try:
             return int(ig_ws[0].split(':')[-1])
         except:
             pass
     return ig_ws_global
 
 
 def _ignorews_url(GET, fileid=None):
     fileid = str(fileid) if fileid else None
     params = defaultdict(list)
     _update_with_GET(params, GET)
     lbl = _('show white space')
     ig_ws = get_ignore_ws(fileid, GET)
     ln_ctx = get_line_ctx(fileid, GET)
     # global option
     if fileid is None:
         if ig_ws is None:
             params['ignorews'] += [1]
             lbl = _('ignore white space')
         ctx_key = 'context'
         ctx_val = ln_ctx
     # per file options
     else:
         if ig_ws is None:
             params[fileid] += ['WS:1']
             lbl = _('ignore white space')
 
         ctx_key = fileid
         ctx_val = 'C:%s' % ln_ctx
     # if we have passed in ln_ctx pass it along to our params
     if ln_ctx:
         params[ctx_key] += [ctx_val]
 
     params['anchor'] = fileid
     img = h.image(h.url('/images/icons/text_strikethrough.png'), lbl, class_='icon')
     return h.link_to(img, h.url.current(**params), title=lbl, class_='tooltip')
 
 
 def get_line_ctx(fid, GET):
     ln_ctx_global = GET.get('context')
     ln_ctx = filter(lambda k: k.startswith('C'), GET.getall(fid))
 
     if ln_ctx:
         retval = ln_ctx[0].split(':')[-1]
     else:
         retval = ln_ctx_global
 
     try:
         return int(retval)
     except:
         return
 
 
 def _context_url(GET, fileid=None):
     """
     Generates url for context lines
 
     :param fileid:
     """
 
     fileid = str(fileid) if fileid else None
     ig_ws = get_ignore_ws(fileid, GET)
     ln_ctx = (get_line_ctx(fileid, GET) or 3) * 2
 
     params = defaultdict(list)
     _update_with_GET(params, GET)
 
     # global option
     if fileid is None:
         if ln_ctx > 0:
             params['context'] += [ln_ctx]
 
         if ig_ws:
             ig_ws_key = 'ignorews'
             ig_ws_val = 1
 
     # per file option
     else:
         params[fileid] += ['C:%s' % ln_ctx]
         ig_ws_key = fileid
         ig_ws_val = 'WS:%s' % 1
 
     if ig_ws:
         params[ig_ws_key] += [ig_ws_val]
 
     lbl = _('%s line context') % ln_ctx
 
     params['anchor'] = fileid
     img = h.image(h.url('/images/icons/table_add.png'), lbl, class_='icon')
     return h.link_to(img, h.url.current(**params), title=lbl, class_='tooltip')
 
 
 class ChangesetController(BaseRepoController):
 
     @LoginRequired()
     @HasRepoPermissionAnyDecorator('repository.read', 'repository.write',
                                    'repository.admin')
     def __before__(self):
         super(ChangesetController, self).__before__()
         c.affected_files_cut_off = 60
         repo_model = RepoModel()
         c.users_array = repo_model.get_users_js()
         c.users_groups_array = repo_model.get_users_groups_js()
 
     def index(self, revision):
 
         c.anchor_url = anchor_url
         c.ignorews_url = _ignorews_url
         c.context_url = _context_url
         limit_off = request.GET.get('fulldiff')
         #get ranges of revisions if preset
         rev_range = revision.split('...')[:2]
         enable_comments = True
         try:
             if len(rev_range) == 2:
                 enable_comments = False
                 rev_start = rev_range[0]
                 rev_end = rev_range[1]
                 rev_ranges = c.rhodecode_repo.get_changesets(start=rev_start,
                                                             end=rev_end)
             else:
                 rev_ranges = [c.rhodecode_repo.get_changeset(revision)]
 
             c.cs_ranges = list(rev_ranges)
             if not c.cs_ranges:
                 raise RepositoryError('Changeset range returned empty result')
 
         except (RepositoryError, ChangesetDoesNotExistError, Exception), e:
             log.error(traceback.format_exc())
             h.flash(str(e), category='warning')
             return redirect(url('home'))
 
         c.changes = OrderedDict()
 
         c.lines_added = 0  # count of lines added
         c.lines_deleted = 0  # count of lines removes
 
         cumulative_diff = 0
         c.cut_off = False  # defines if cut off limit is reached
         c.changeset_statuses = ChangesetStatus.STATUSES
         c.comments = []
         c.statuses = []
         c.inline_comments = []
         c.inline_cnt = 0
         # Iterate over ranges (default changeset view is always one changeset)
         for changeset in c.cs_ranges:
 
             c.statuses.extend([ChangesetStatusModel()\
                               .get_status(c.rhodecode_db_repo.repo_id,
                                           changeset.raw_id)])
 
             c.comments.extend(ChangesetCommentsModel()\
                               .get_comments(c.rhodecode_db_repo.repo_id,
                                             revision=changeset.raw_id))
             inlines = ChangesetCommentsModel()\
                         .get_inline_comments(c.rhodecode_db_repo.repo_id,
                                              revision=changeset.raw_id)
             c.inline_comments.extend(inlines)
             c.changes[changeset.raw_id] = []
             try:
                 changeset_parent = changeset.parents[0]
             except IndexError:
                 changeset_parent = None
 
             #==================================================================
             # ADDED FILES
             #==================================================================
             for node in changeset.added:
                 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=None,
                     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(
                     ('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 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')
                 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 = filenode_old.changeset.raw_id
                 cs2 = node.changeset.raw_id
                 c.changes.append(('changed', node, diff, cs1, cs2))
 
         response.content_type = 'text/plain'
 
         if method == 'download':
             response.content_disposition = 'attachment; filename=%s.patch' \
                                             % revision
 
         c.parent_tmpl = ''.join(['# Parent  %s\n' % x.raw_id
                                  for x in c.changeset.parents])
 
         c.diffs = ''
         for x in c.changes:
             c.diffs += x[2]
 
         return render('changeset/raw_changeset.html')
 
     @jsonify
     def comment(self, repo_name, revision):
         status = request.POST.get('changeset_status')
         change_status = request.POST.get('change_changeset_status')
 
         comm = ChangesetCommentsModel().create(
             text=request.POST.get('text'),
-            repo_id=c.rhodecode_db_repo.repo_id,
-            user_id=c.rhodecode_user.user_id,
+            repo=c.rhodecode_db_repo.repo_id,
+            user=c.rhodecode_user.user_id,
             revision=revision,
             f_path=request.POST.get('f_path'),
             line_no=request.POST.get('line'),
             status_change=(ChangesetStatus.get_status_lbl(status)
                            if status and change_status else None)
         )
 
         # get status if set !
         if status and change_status:
             ChangesetStatusModel().set_status(
                 c.rhodecode_db_repo.repo_id,
                 status,
                 c.rhodecode_user.user_id,
                 comm,
                 revision=revision,
             )
         action_logger(self.rhodecode_user,
                       'user_commented_revision:%s' % revision,
                       c.rhodecode_db_repo, self.ip_addr, self.sa)
 
         Session.commit()
 
         if not request.environ.get('HTTP_X_PARTIAL_XHR'):
             return redirect(h.url('changeset_home', repo_name=repo_name,
                                   revision=revision))
 
         data = {
            'target_id': h.safeid(h.safe_unicode(request.POST.get('f_path'))),
         }
         if comm:
             c.co = comm
             data.update(comm.get_dict())
             data.update({'rendered_text':
                          render('changeset/changeset_comment_block.html')})
 
         return data
 
     @jsonify
     def delete_comment(self, repo_name, comment_id):
         co = ChangesetComment.get(comment_id)
         owner = lambda: co.author.user_id == c.rhodecode_user.user_id
         if h.HasPermissionAny('hg.admin', 'repository.admin')() or owner:
             ChangesetCommentsModel().delete(comment=co)
             Session.commit()
             return True
         else:
             raise HTTPForbidden()

rhodecode/controllers/pullrequests.py

@@ -1,308 +1,328 b''
 # -*- 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 <[e-mail]>
     :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 webob.exc import HTTPNotFound, HTTPForbidden
 from collections import defaultdict
 from itertools import groupby
 
 from pylons import request, response, session, tmpl_context as c, url
 from pylons.controllers.util import abort, redirect
 from pylons.i18n.translation import _
 from pylons.decorators import jsonify
 
+from rhodecode.lib.compat import json
 from rhodecode.lib.base import BaseRepoController, render
 from rhodecode.lib.auth import LoginRequired, HasRepoPermissionAnyDecorator
 from rhodecode.lib import helpers as h
 from rhodecode.lib import diffs
 from rhodecode.lib.utils import action_logger
 from rhodecode.model.db import User, PullRequest, ChangesetStatus,\
     ChangesetComment
 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:%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
 
         if org_repo.scm_instance.alias != 'hg':
             log.error('Review not available for GIT REPOS')
             raise HTTPNotFound
 
+        other_repos_info = {}
+
         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)
+
+        #add orginal repo
+        other_repos_info[org_repo.repo_name] = {
+            'gravatar': h.gravatar_url(org_repo.user.email, 24),
+            'description': org_repo.description
+        }
+
         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))
                                  )
+            other_repos_info[fork.repo_name] = {
+                'gravatar': h.gravatar_url(fork.user.email, 24),
+                'description': fork.description
+            }
         #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))
                                      )
+            other_repos_info[org_repo.parent.repo_name] = {
+                'gravatar': h.gravatar_url(org_repo.parent.user.email, 24),
+                'description': org_repo.parent.description
+            }
 
+        c.other_repos_info = json.dumps(other_repos_info)
         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()
-            pull_request = model.create(self.rhodecode_user.user_id, org_repo,
-                         org_ref, other_repo, other_ref, revisions,
-                         reviewers, title, description)
-            Session.commit()
+            pull_request = PullRequestModel().create(
+                self.rhodecode_user.user_id, org_repo, org_ref, other_repo,
+                other_ref, revisions, reviewers, title, description
+            )
+            Session().commit()
             h.flash(_('Successfully opened new pull request'),
                     category='success')
         except Exception:
             h.flash(_('Error occurred during sending pull request'),
                     category='error')
             log.error(traceback.format_exc())
+            return redirect(url('changelog_home', repo_name=org_repo,))
 
         return redirect(url('pullrequest_show', repo_name=other_repo,
                             pull_request_id=pull_request.pull_request_id))
 
     def _load_compare_data(self, pull_request):
         """
         Load context data needed for generating compare diff
 
         :param pull_request:
         :type 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
 
         c.cs_ranges, discovery_data = PullRequestModel().get_compare_data(
                                        org_repo, org_ref, other_repo, other_ref
                                       )
 
         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)
 
         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=True,
                                           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_or_404(pull_request_id)
 
         cc_model = ChangesetCommentsModel()
         cs_model = ChangesetStatusModel()
         _cs_statuses = cs_model.get_statuses(c.pull_request.org_repo,
                                             pull_request=c.pull_request,
                                             with_revisions=True)
 
         cs_statuses = defaultdict(list)
         for st in _cs_statuses:
             cs_statuses[st.author.username] += [st]
 
         c.pull_request_reviewers = []
         for o in c.pull_request.reviewers:
             st = cs_statuses.get(o.user.username, None)
             if st:
                 sorter = lambda k: k.version
                 st = [(x, list(y)[0])
                       for x, y in (groupby(sorted(st, key=sorter), sorter))]
             c.pull_request_reviewers.append([o.user, st])
 
         # pull_requests repo_name we opened it against
         # ie. other_repo must match
         if repo_name != c.pull_request.other_repo.repo_name:
             raise HTTPNotFound
 
         # load compare data into template context
         self._load_compare_data(c.pull_request)
 
         # inline comments
         c.inline_cnt = 0
         c.inline_comments = cc_model.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 = cc_model.get_comments(c.rhodecode_db_repo.repo_id,
                                            pull_request=pull_request_id)
 
         # changeset(pull-request) status
         c.current_changeset_status = cs_model.calculate_status(
                                         c.pull_request_reviewers
                                      )
         c.changeset_statuses = ChangesetStatus.STATUSES
         c.target_repo = c.pull_request.org_repo.repo_name
         return render('/pullrequests/pullrequest_show.html')
 
     @jsonify
     def comment(self, repo_name, pull_request_id):
 
         status = request.POST.get('changeset_status')
         change_status = request.POST.get('change_changeset_status')
 
         comm = ChangesetCommentsModel().create(
             text=request.POST.get('text'),
-            repo_id=c.rhodecode_db_repo.repo_id,
-            user_id=c.rhodecode_user.user_id,
+            repo=c.rhodecode_db_repo.repo_id,
+            user=c.rhodecode_user.user_id,
             pull_request=pull_request_id,
             f_path=request.POST.get('f_path'),
             line_no=request.POST.get('line'),
             status_change=(ChangesetStatus.get_status_lbl(status)
                            if status and change_status else None)
         )
 
         # get status if set !
         if status and change_status:
             ChangesetStatusModel().set_status(
                 c.rhodecode_db_repo.repo_id,
                 status,
                 c.rhodecode_user.user_id,
                 comm,
                 pull_request=pull_request_id
             )
         action_logger(self.rhodecode_user,
                       'user_commented_pull_request:%s' % pull_request_id,
                       c.rhodecode_db_repo, self.ip_addr, self.sa)
 
-        Session.commit()
+        Session().commit()
 
         if not request.environ.get('HTTP_X_PARTIAL_XHR'):
             return redirect(h.url('pullrequest_show', repo_name=repo_name,
                                   pull_request_id=pull_request_id))
 
         data = {
            'target_id': h.safeid(h.safe_unicode(request.POST.get('f_path'))),
         }
         if comm:
             c.co = comm
             data.update(comm.get_dict())
             data.update({'rendered_text':
                          render('changeset/changeset_comment_block.html')})
 
         return data
 
     @jsonify
     def delete_comment(self, repo_name, comment_id):
         co = ChangesetComment.get(comment_id)
         owner = lambda: co.author.user_id == c.rhodecode_user.user_id
         if h.HasPermissionAny('hg.admin', 'repository.admin')() or owner:
             ChangesetCommentsModel().delete(comment=co)
-            Session.commit()
+            Session().commit()
             return True
         else:
             raise HTTPForbidden()
  No newline at end of file

rhodecode/model/comment.py

@@ -1,213 +1,224 b''
 # -*- coding: utf-8 -*-
 """
     rhodecode.model.comment
     ~~~~~~~~~~~~~~~~~~~~~~~
 
     comments model for RhodeCode
 
     :created_on: Nov 11, 2011
     :author: marcink
     :copyright: (C) 2011-2012 Marcin Kuzminski <[e-mail]>
     :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, PullRequest
 from rhodecode.model.notification import NotificationModel
 
 log = logging.getLogger(__name__)
 
 
 class ChangesetCommentsModel(BaseModel):
 
     cls = ChangesetComment
 
     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=None, pull_request=None,
+    def create(self, text, repo, user, revision=None, pull_request=None,
                f_path=None, line_no=None, status_change=None):
         """
         Creates new comment for changeset or pull request.
         IF status_change is not none this comment is associated with a
         status change of changeset or changesets associated with pull request
 
         :param text:
-        :param repo_id:
-        :param user_id:
+        :param repo:
+        :param user:
         :param revision:
         :param pull_request:
         :param f_path:
         :param line_no:
         :param status_change:
         """
         if not text:
             return
 
-        repo = Repository.get(repo_id)
+        repo = self._get_repo(repo)
+        user = self._get_user(user)
         comment = ChangesetComment()
         comment.repo = repo
-        comment.user_id = user_id
+        comment.author = user
         comment.text = text
         comment.f_path = f_path
         comment.line_no = line_no
 
         if revision:
             cs = repo.scm_instance.get_changeset(revision)
             desc = "%s - %s" % (cs.short_id, h.shorter(cs.message, 256))
             author_email = cs.author_email
             comment.revision = revision
         elif pull_request:
             pull_request = self.__get_pull_request(pull_request)
             comment.pull_request = pull_request
-            desc = ''
+            desc = pull_request.pull_request_id
         else:
             raise Exception('Please specify revision or pull_request_id')
 
         self.sa.add(comment)
         self.sa.flush()
 
         # make notification
         line = ''
         body = text
 
         #changeset
         if revision:
             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.link_to('Re commit: %(desc)s %(line)s' % \
+                          {'desc': desc, 'line': line},
                           h.url('changeset_home', repo_name=repo.repo_name,
                                 revision=revision,
                                 anchor='comment-%s' % comment.comment_id,
                                 qualified=True,
                           )
                 )
             )
             notification_type = Notification.TYPE_CHANGESET_COMMENT
             # 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)]
         #pull request
         elif pull_request:
-            #TODO: make this something usefull
-            subj = 'commented on pull request something...'
+            subj = safe_unicode(
+                h.link_to('Re pull request: %(desc)s %(line)s' % \
+                          {'desc': desc, 'line': line},
+                          h.url('pullrequest_show',
+                                repo_name=pull_request.other_repo.repo_name,
+                                pull_request_id=pull_request.pull_request_id,
+                                anchor='comment-%s' % comment.comment_id,
+                                qualified=True,
+                          )
+                )
+            )
+
             notification_type = Notification.TYPE_PULL_REQUEST_COMMENT
             # get the current participants of this pull request
             recipients = ChangesetComment.get_users(pull_request_id=
                                                 pull_request.pull_request_id)
             # add pull request author
             recipients += [pull_request.author]
 
         # create notification objects, and emails
         NotificationModel().create(
-          created_by=user_id, subject=subj, body=body,
+          created_by=user, subject=subj, body=body,
           recipients=recipients, type_=notification_type,
           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,
+                created_by=user, subject=subj, body=body,
                 recipients=mention_recipients,
                 type_=notification_type,
                 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=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:
         :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:
             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')
         return q.all()
 
     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:
             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/pull_request.py

@@ -1,189 +1,196 b''
 # -*- 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 <[e-mail]>
     :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 binascii
 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.db import PullRequest, PullRequestReviewers, Notification,\
+    ChangesetStatus
 from rhodecode.model.notification import NotificationModel
 from rhodecode.lib.utils2 import safe_unicode
 
 from rhodecode.lib.vcs.utils.hgcompat import discovery
+from rhodecode.model.changeset_status import ChangesetStatusModel
+from rhodecode.model.comment import ChangesetCommentsModel
+from rhodecode.model.meta import Session
 
 log = logging.getLogger(__name__)
 
 
 class PullRequestModel(BaseModel):
 
     cls = PullRequest
 
     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)
+        org_repo = self._get_repo(org_repo)
+        other_repo = self._get_repo(other_repo)
 
         new = PullRequest()
-        new.org_repo = self._get_repo(org_repo)
+        new.org_repo = org_repo
         new.org_ref = org_ref
-        new.other_repo = self._get_repo(other_repo)
+        new.other_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)
-
+        Session().flush()
         #members
         for member in reviewers:
             _usr = self._get_user(member)
             reviewer = PullRequestReviewers(_usr, new)
             self.sa.add(reviewer)
 
         #notification to reviewers
         notif = NotificationModel()
 
         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,
+        notif.create(created_by=created_by_user, subject=subject, body=body,
                      recipients=reviewers,
                      type_=Notification.TYPE_PULL_REQUEST,)
 
         return new
 
     def _get_changesets(self, org_repo, org_ref, other_repo, other_ref,
                         discovery_data):
         """
         Returns a list of changesets that are incoming from org_repo@org_ref
         to other_repo@other_ref
 
         :param org_repo:
         :type org_repo:
         :param org_ref:
         :type org_ref:
         :param other_repo:
         :type other_repo:
         :param other_ref:
         :type other_ref:
         :param tmp:
         :type tmp:
         """
         changesets = []
         #case two independent repos
         if org_repo != other_repo:
             common, incoming, rheads = discovery_data
 
             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):
         """
         Get's mercurial discovery data used to calculate difference between
         repos and refs
 
         :param org_repo:
         :type org_repo:
         :param org_ref:
         :type org_ref:
         :param other_repo:
         :type other_repo:
         :param other_ref:
         :type other_ref:
         """
 
         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 get_compare_data(self, org_repo, org_ref, other_repo, other_ref):
         """
         Returns a tuple of incomming changesets, and discoverydata cache
 
         :param org_repo:
         :type org_repo:
         :param org_ref:
         :type org_ref:
         :param other_repo:
         :type other_repo:
         :param other_ref:
         :type other_ref:
         """
 
         if len(org_ref) != 2 or not isinstance(org_ref, (list, tuple)):
             raise Exception('org_ref must be a two element list/tuple')
 
         if len(other_ref) != 2 or not isinstance(org_ref, (list, tuple)):
             raise Exception('other_ref must be a two element list/tuple')
 
         discovery_data = self._get_discovery(org_repo.scm_instance,
                                            org_ref,
                                            other_repo.scm_instance,
                                            other_ref)
         cs_ranges = self._get_changesets(org_repo.scm_instance,
                                            org_ref,
                                            other_repo.scm_instance,
                                            other_ref,
                                            discovery_data)
         return cs_ranges, discovery_data

rhodecode/templates/pullrequests/pullrequest.html

@@ -1,192 +1,196 b''
 <%inherit file="/base/base.html"/>
 
 <%def name="title()">
     ${c.repo_name} ${_('New pull request')}
 </%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;
     ${_('New pull request')}
 </%def>
 
 <%def name="main()">
 
 <div class="box">
     <!-- box / title -->
     <div class="title">
         ${self.breadcrumbs()}
     </div>
     ${h.form(url('pullrequest', repo_name=c.repo_name), method='post', id='pull_request_form')}
     <div style="float:left;padding:0px 30px 30px 30px">
        <div style="padding:0px 5px 5px 5px">
          <span>
            <a id="refresh" href="#">
              <img class="icon" title="${_('Refresh')}" alt="${_('Refresh')}" src="${h.url('/images/icons/arrow_refresh.png')}"/>
              ${_('refresh overview')}
            </a>
          </span>
        </div>
         ##ORG
         <div style="float:left">
             <div class="fork_user">
                 <div class="gravatar">
                     <img alt="gravatar" src="${h.gravatar_url(c.rhodecode_db_repo.user.email,24)}"/>
                 </div>
                 <span style="font-size: 20px">
                 ${h.select('org_repo','',c.org_repos,class_='refs')}:${h.select('org_ref','',c.org_refs,class_='refs')}
                 </span>
                  <div style="padding:5px 3px 3px 42px;">${c.rhodecode_db_repo.description}</div>
             </div>
             <div style="clear:both;padding-top: 10px"></div>
         </div>
           <div style="float:left;font-size:24px;padding:0px 20px">
           <img height=32 width=32 src="${h.url('/images/arrow_right_64.png')}"/>
           </div>
 
         ##OTHER, most Probably the PARENT OF THIS FORK
         <div style="float:left">
             <div class="fork_user">
                 <div class="gravatar">
-                    <img alt="gravatar" src="${h.gravatar_url(c.rhodecode_db_repo.user.email,24)}"/>
+                    <img id="other_repo_gravatar" alt="gravatar" src=""/>
                 </div>
                 <span style="font-size: 20px">
                 ${h.select('other_repo',c.default_pull_request ,c.other_repos,class_='refs')}:${h.select('other_ref','',c.other_refs,class_='refs')}
                 </span>
-                 <div style="padding:5px 3px 3px 42px;">${c.rhodecode_db_repo.description}</div>
+                 <div id="other_repo_desc" style="padding:5px 3px 3px 42px;"></div>
             </div>
             <div style="clear:both;padding-top: 10px"></div>
         </div>
        <div style="clear:both;padding-top: 10px"></div>
        ## overview pulled by ajax
        <div style="float:left" id="pull_request_overview"></div>
        <div style="float:left;clear:both;padding:10px 10px 10px 0px;display:none">
             <a id="pull_request_overview_url" href="#">${_('Detailed compare view')}</a>
        </div>
      </div>
     <div style="float:left; border-left:1px dashed #eee">
         <h4>${_('Pull request reviewers')}</h4>
         <div id="reviewers" style="padding:0px 0px 0px 15px">
         ##TODO: make this nicer :)
           <table class="table noborder">
                   <tr>
                       <td>
                           <div>
                               <div style="float:left">
                                   <div class="text" style="padding: 0px 0px 6px;">${_('Chosen reviewers')}</div>
                                   ${h.select('review_members',[x[0] for x in c.review_members],c.review_members,multiple=True,size=8,style="min-width:210px")}
                                  <div  id="remove_all_elements" style="cursor:pointer;text-align:center">
                                      ${_('Remove all elements')}
                                      <img alt="remove" style="vertical-align:text-bottom" src="${h.url('/images/icons/arrow_right.png')}"/>
                                  </div>
                               </div>
                               <div style="float:left;width:20px;padding-top:50px">
                                   <img alt="add" id="add_element"
                                       style="padding:2px;cursor:pointer"
                                       src="${h.url('/images/icons/arrow_left.png')}"/>
                                   <br />
                                   <img alt="remove" id="remove_element"
                                       style="padding:2px;cursor:pointer"
                                       src="${h.url('/images/icons/arrow_right.png')}"/>
                               </div>
                               <div style="float:left">
                                    <div class="text" style="padding: 0px 0px 6px;">${_('Available reviewers')}</div>
                                    ${h.select('available_members',[],c.available_members,multiple=True,size=8,style="min-width:210px")}
                                    <div id="add_all_elements" style="cursor:pointer;text-align:center">
                                          <img alt="add" style="vertical-align:text-bottom" src="${h.url('/images/icons/arrow_left.png')}"/>
                                           ${_('Add all elements')}
                                    </div>
                               </div>
                           </div>
                       </td>
                   </tr>
           </table>
         </div>
     </div>
     <h3>${_('Create new pull request')}</h3>
 
     <div class="form">
         <!-- fields -->
 
         <div class="fields">
 
              <div class="field">
                 <div class="label">
                     <label for="pullrequest_title">${_('Title')}:</label>
                 </div>
                 <div class="input">
                     ${h.text('pullrequest_title',size=30)}
                 </div>
              </div>
 
             <div class="field">
                 <div class="label label-textarea">
                     <label for="pullrequest_desc">${_('description')}:</label>
                 </div>
                 <div class="textarea text-area editor">
                     ${h.textarea('pullrequest_desc',size=30)}
                 </div>
             </div>
 
             <div class="buttons">
                 ${h.submit('save',_('Send pull request'),class_="ui-button")}
                 ${h.reset('reset',_('Reset'),class_="ui-button")}
            </div>
         </div>
     </div>
     ${h.end_form()}
 
 </div>
 
 <script type="text/javascript">
   MultiSelectWidget('review_members','available_members','pull_request_form');
-
+  var other_repos_info = ${c.other_repos_info|n};
   var loadPreview = function(){
 	  YUD.setStyle(YUD.get('pull_request_overview_url').parentElement,'display','none');
       var url = "${h.url('compare_url',
           repo_name='org_repo',
           org_ref_type='branch', org_ref='org_ref',
           other_ref_type='branch', other_ref='other_ref',
           repo='other_repo',
           as_form=True)}";
 
       var select_refs = YUQ('#pull_request_form select.refs')
 
       for(var i=0;i<select_refs.length;i++){
         var select_ref = select_refs[i];
         var select_ref_data = select_ref.value.split(':');
         var key = null;
         var val = null;
         if(select_ref_data.length>1){
           key = select_ref.name+"_type";
           val = select_ref_data[0];
           url = url.replace(key,val);
 
           key = select_ref.name;
           val = select_ref_data[1];
           url = url.replace(key,val);
 
         }else{
           key = select_ref.name;
           val = select_ref.value;
           url = url.replace(key,val);
         }
       }
 
       ypjax(url,'pull_request_overview', function(data){
+    	  var sel_box = YUQ('#pull_request_form #other_repo')[0];
+    	  var repo_name = sel_box.options[sel_box.selectedIndex].value;
     	  YUD.get('pull_request_overview_url').href = url;
     	  YUD.setStyle(YUD.get('pull_request_overview_url').parentElement,'display','');
+    	  YUD.get('other_repo_gravatar').src = other_repos_info[repo_name]['gravatar'];
+    	  YUD.get('other_repo_desc').innerHTML = other_repos_info[repo_name]['description'];
       })
   }
   YUE.on('refresh','click',function(e){
      loadPreview()
   })
 
   //lazy load overview after 0.5s
   setTimeout(loadPreview, 500)
 
 </script>
 
 </%def>