c.org_repos.append((org_repo.repo_name, '%s/%s' % (

                                org_repo.user.username, c.repo_name))

                           )

        # add org repo to other so we can open pull request agains itself

        c.other_repos.extend(c.org_repos)

        c.default_pull_request = org_repo.repo_name

        c.default_revs = self._get_repo_refs(org_repo.scm_instance)

        #add orginal repo

        other_repos_info[org_repo.repo_name] = {

            'gravatar': h.gravatar_url(org_repo.user.email, 24),

            'description': org_repo.description,

            'revs': h.select('other_ref', '', c.default_revs, class_='refs')

        }

        #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,

                'revs': h.select('other_ref', '',

                                 self._get_repo_refs(fork.scm_instance),

                                 class_='refs')

            }

        #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,

                'revs': h.select('other_ref', '',

                                 self._get_repo_refs(org_repo.parent.scm_instance),

                                 class_='refs')

            }

        c.other_repos_info = json.dumps(other_repos_info)

        c.review_members = [org_repo.user]

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

    @NotAnonymous()

    def create(self, repo_name):

        try:

            _form = PullRequestForm()().to_python(request.POST)

        except formencode.Invalid, errors:

            log.error(traceback.format_exc())

            if errors.error_dict.get('revisions'):

                msg = 'Revisions: %s' % errors.error_dict['revisions']

            elif errors.error_dict.get('pullrequest_title'):

                msg = _('Pull request requires a title with min. 3 chars')

            else:

                msg = _('error during creation of pull request')

            h.flash(msg, 'error')

            return redirect(url('pullrequest_home', repo_name=repo_name))

        org_repo = _form['org_repo']

        org_ref = _form['org_ref']

        other_repo = _form['other_repo']

        other_ref = _form['other_ref']

        revisions = _form['revisions']

        reviewers = _form['review_members']

        title = _form['pullrequest_title']

        description = _form['pullrequest_desc']

        try:

            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('pullrequest_home', repo_name=repo_name))

        return redirect(url('pullrequest_show', repo_name=other_repo,

                            pull_request_id=pull_request.pull_request_id))

    @NotAnonymous()

    @jsonify

    def update(self, repo_name, pull_request_id):

        pull_request = PullRequest.get_or_404(pull_request_id)

        if pull_request.is_closed():

            raise HTTPForbidden()

    @NotAnonymous()

    @jsonify

    def delete(self, repo_name, pull_request_id):

        pull_request = PullRequest.get_or_404(pull_request_id)

        #only owner can delete it !

        if pull_request.author.user_id == c.rhodecode_user.user_id:

            PullRequestModel().delete(pull_request)

            Session().commit()

            h.flash(_('Successfully deleted pull request'),

                    category='success')

            return redirect(url('admin_settings_my_account'))

    def _load_compare_data(self, pull_request, enable_comments=True):

        """

        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_name,

         org_ref_rev) = pull_request.org_ref.split(':')

        other_repo = pull_request.other_repo

        (other_ref_type,

         other_ref_name,

         other_ref_rev) = pull_request.other_ref.split(':')

        # despite opening revisions for bookmarks/branches/tags, we always

        # convert this to rev to prevent changes after book or branch change

        org_ref = ('rev', org_ref_rev)

        other_ref = ('rev', other_ref_rev)

        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=enable_comments,

                                          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 = []

        c.pull_request_pending_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))]

            else:

                c.pull_request_pending_reviewers.append(o.user)

            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

        enable_comments = not c.pull_request.is_closed()

        self._load_compare_data(c.pull_request, enable_comments=enable_comments)

        # 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)

import logging

import datetime

from sqlalchemy import *

from sqlalchemy.exc import DatabaseError

from sqlalchemy.orm import relation, backref, class_mapper

from sqlalchemy.orm.session import Session

from sqlalchemy.ext.declarative import declarative_base

from rhodecode.lib.dbmigrate.migrate import *

from rhodecode.lib.dbmigrate.migrate.changeset import *

from rhodecode.model.meta import Base

from rhodecode.model import meta

log = logging.getLogger(__name__)

def upgrade(migrate_engine):

    """

    Upgrade operations go here.

    Don't create your own engine; bind migrate_engine to your metadata

    """

    #==========================================================================

    # USEREMAILMAP

    #==========================================================================

    from rhodecode.lib.dbmigrate.schema.db_1_4_0 import UserEmailMap

    tbl = UserEmailMap.__table__

    tbl.create()

    #==========================================================================

    # PULL REQUEST

    #==========================================================================

    from rhodecode.lib.dbmigrate.schema.db_1_4_0 import PullRequest

    tbl = PullRequest.__table__

    tbl.create()

    #==========================================================================

    # PULL REQUEST REVIEWERS

    #==========================================================================

    from rhodecode.lib.dbmigrate.schema.db_1_4_0 import PullRequestReviewers

    tbl = PullRequestReviewers.__table__

    tbl.create()

    #==========================================================================

    # CHANGESET STATUS

    #==========================================================================

    from rhodecode.lib.dbmigrate.schema.db_1_4_0 import ChangesetStatus

    tbl = ChangesetStatus.__table__

    tbl.create()

    ## RESET COMPLETLY THE metadata for sqlalchemy to use the 1_3_0 Base 

    Base = declarative_base()

    Base.metadata.clear()

    Base.metadata = MetaData()

    Base.metadata.bind = migrate_engine

    meta.Base = Base

    #==========================================================================

    # USERS TABLE

    #==========================================================================

    from rhodecode.lib.dbmigrate.schema.db_1_3_0 import User

    tbl = User.__table__

    # change column name -> firstname

    col = User.__table__.columns.name

    col.alter(index=Index('u_username_idx', 'username'))

    col.alter(index=Index('u_email_idx', 'email'))

    col.alter(name="firstname", table=tbl)

    inherit_default_permissions = Column("inherit_default_permissions",

                                         Boolean(), nullable=True, unique=None,

                                         default=True)

    inherit_default_permissions.create(table=tbl)

    inherit_default_permissions.alter(nullable=False, default=True, table=tbl)

    #==========================================================================

    # REPOSITORIES

    #==========================================================================

    from rhodecode.lib.dbmigrate.schema.db_1_3_0 import Repository

    tbl = Repository.__table__

    enable_locking = Column("enable_locking", Boolean(), nullable=True,

                            unique=None, default=False)

    enable_locking.create(table=tbl)

    enable_locking.alter(nullable=False, default=False, table=tbl)

    _locked = Column("locked", String(255), nullable=True, unique=False,

                     default=None)

    _locked.create(table=tbl)

    landing_rev = Column("landing_revision", String(255), nullable=True,

                         unique=False, default='tip')

    landing_rev.create(table=tbl)

    landing_rev.alter(nullable=False, default='tip', table=tbl)

    #==========================================================================

    # GROUPS

    #==========================================================================

    from rhodecode.lib.dbmigrate.schema.db_1_3_0 import RepoGroup

    tbl = RepoGroup.__table__

    enable_locking = Column("enable_locking", Boolean(), nullable=True,

                            unique=None, default=False)

    enable_locking.create(table=tbl)

    enable_locking.alter(nullable=False, default=False)

    #==========================================================================

    # CACHE INVALIDATION

    #==========================================================================

    from rhodecode.lib.dbmigrate.schema.db_1_3_0 import CacheInvalidation

    tbl = CacheInvalidation.__table__

    col = CacheInvalidation.__table__.columns.cache_key

    col.alter(index=Index('key_idx', 'cache_key'))

    #==========================================================================

    # NOTIFICATION

    #==========================================================================

    from rhodecode.lib.dbmigrate.schema.db_1_3_0 import Notification

    tbl = Notification.__table__

    col = Notification.__table__.columns.type

    col.alter(index=Index('notification_type_idx', 'type'),)

    #==========================================================================

    # CHANGESET_COMMENTS

    #==========================================================================

    from rhodecode.lib.dbmigrate.schema.db_1_3_0 import ChangesetComment

    tbl = ChangesetComment.__table__

    col.alter(index=Index('cc_revision_idx', 'revision'),)

    hl_lines = Column('hl_lines', Unicode(512), nullable=True)

    hl_lines.create(table=tbl)

    created_on = Column('created_on', DateTime(timezone=False), nullable=True,

                        default=datetime.datetime.now)

    created_on.create(table=tbl)

    created_on.alter(nullable=False, default=datetime.datetime.now)

    modified_at = Column('modified_at', DateTime(timezone=False), nullable=False,

                         default=datetime.datetime.now)

    modified_at.alter(type=DateTime(timezone=False), table=tbl)

    pull_request_id = Column("pull_request_id", Integer(),

                             ForeignKey('pull_requests.pull_request_id'),

                             nullable=True)

    pull_request_id.create(table=tbl)

    ## RESET COMPLETLY THE metadata for sqlalchemy back after using 1_3_0

    Base = declarative_base()

    Base.metadata.clear()

    Base.metadata = MetaData()

    Base.metadata.bind = migrate_engine

    meta.Base = Base

def downgrade(migrate_engine):

    meta = MetaData()

    meta.bind = migrate_engine