@NotAnonymous()

    def my_account_update(self):

        """PUT /_admin/my_account_update: Update an existing item"""

        # Forms posted to this method should contain a hidden field:

        #    <input type="hidden" name="_method" value="PUT" />

        # Or using helpers:

        #    h.form(url('admin_settings_my_account_update'),

        #           method='put')

        # url('admin_settings_my_account_update', id=ID)

        uid = self.rhodecode_user.user_id

        c.user = User.get(self.rhodecode_user.user_id)

        c.ldap_dn = c.user.ldap_dn

        email = self.rhodecode_user.email

        _form = UserForm(edit=True,

                         old_data={'user_id': uid, 'email': email})()

        form_result = {}

        try:

            form_result = _form.to_python(dict(request.POST))

            skip_attrs = ['admin', 'active']  # skip attr for my account

            if c.ldap_dn:

                #forbid updating username for ldap accounts

                skip_attrs.append('username')

            UserModel().update(uid, form_result, skip_attrs=skip_attrs)

            h.flash(_('Your account was updated successfully'),

                    category='success')

            Session().commit()

        except formencode.Invalid, errors:

            #json used to render the grid

            c.data = self._load_my_repos_data()

            c.form = htmlfill.render(

                render('admin/users/user_edit_my_account_form.html'),

                defaults=errors.value,

                errors=errors.error_dict or {},

                prefix_error=False,

                encoding="UTF-8")

            return render('admin/users/user_edit_my_account.html')

        except Exception:

            log.error(traceback.format_exc())

            h.flash(_('error occurred during update of user %s') \

                    % form_result.get('username'), category='error')

        return redirect(url('my_account'))

    @NotAnonymous()

    def my_account_my_pullrequests(self):

        c.my_pull_requests = PullRequest.query()\

                                .filter(PullRequest.user_id ==

                                        self.rhodecode_user.user_id)\

                                .all()

            [x.pull_request for x in PullRequestReviewers.query()\

                                    .filter(PullRequestReviewers.user_id ==

                                            self.rhodecode_user.user_id)\

        return render('admin/users/user_edit_my_account_pullrequests.html')

    @NotAnonymous()

    def create_repository(self):

        """GET /_admin/create_repository: Form to create a new item"""

        new_repo = request.GET.get('repo', '')

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

        if not HasPermissionAny('hg.admin', 'hg.create.repository')():

            #you're not super admin nor have global create permissions,

            #but maybe you have at least write permission to a parent group ?

            _gr = RepoGroup.get(parent_group)

            gr_name = _gr.group_name if _gr else None

            if not HasReposGroupPermissionAny('group.admin', 'group.write')(group_name=gr_name):

                raise HTTPForbidden

        acl_groups = GroupList(RepoGroup.query().all(),

                               perm_set=['group.write', 'group.admin'])

        c.repo_groups = RepoGroup.groups_choices(groups=acl_groups)

        c.repo_groups_choices = map(lambda k: unicode(k[0]), c.repo_groups)

        choices, c.landing_revs = ScmModel().get_repo_landing_revs()

        c.new_repo = repo_name_slug(new_repo)

        ## apply the defaults from defaults page

        defaults = RhodeCodeSetting.get_default_repo_settings(strip_prefix=True)

        if parent_group:

            defaults.update({'repo_group': parent_group})

        return htmlfill.render(

            render('admin/repos/repo_add.html'),

            defaults=defaults,

            errors={},

            prefix_error=False,

            encoding="UTF-8"

        )

    def _get_hg_ui_settings(self):

        ret = RhodeCodeUi.query().all()

        if not ret:

            raise Exception('Could not get application ui settings !')

        settings = {}

        for each in ret:

            k = each.ui_key

            v = each.ui_value

            if k == '/':

                k = 'root_path'

    :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

import datetime

import re

from pylons.i18n.translation import _

from rhodecode.model.meta import Session

from rhodecode.lib import helpers as h, unionrepo

from rhodecode.model import BaseModel

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 scmutil

from rhodecode.lib.vcs.utils import safe_str

from rhodecode.lib.vcs.backends.base import EmptyChangeset

log = logging.getLogger(__name__)

class PullRequestModel(BaseModel):

    cls = PullRequest

    def __get_pull_request(self, pull_request):

        return self._get_instance(PullRequest, pull_request)

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

        from rhodecode.model.changeset_status import ChangesetStatusModel

        created_by_user = self._get_user(created_by)

        org_repo = self._get_repo(org_repo)

        other_repo = self._get_repo(other_repo)

        new = PullRequest()

        new.org_repo = org_repo

        new.org_ref = org_ref

        new.other_repo = other_repo

        new.other_ref = other_ref

        new.revisions = revisions

        new.title = title

        new.description = description

        new.author = created_by_user

        self.sa.add(new)

        Session().flush()

        #members

            _usr = self._get_user(member)

            reviewer = PullRequestReviewers(_usr, new)

            self.sa.add(reviewer)

        #reset state to under-review

        ChangesetStatusModel().set_status(

            repo=org_repo,

            status=ChangesetStatus.STATUS_UNDER_REVIEW,

            user=created_by_user,

            pull_request=new

        )

        #notification to reviewers

        notif = NotificationModel()

        pr_url = h.url('pullrequest_show', repo_name=other_repo.repo_name,

                       pull_request_id=new.pull_request_id,

                       qualified=True,

        )

        subject = safe_unicode(

            h.link_to(

              _('%(user)s wants you to review pull request #%(pr_id)s: %(pr_title)s') % \

                {'user': created_by_user.username,

                 'pr_title': new.title,

                 'pr_id': new.pull_request_id},

                pr_url

            )

        )

        body = description

        kwargs = {

            'pr_title': title,

            'pr_user_created': h.person(created_by_user.email),

            'pr_repo_url': h.url('summary_home', repo_name=other_repo.repo_name,

                                 qualified=True,),

            'pr_url': pr_url,

            'pr_revisions': revisions

        }

        notif.create(created_by=created_by_user, subject=subject, body=body,

                     recipients=reviewers,

                     type_=Notification.TYPE_PULL_REQUEST, email_kwargs=kwargs)

        return new

    def update_reviewers(self, pull_request, reviewers_ids):

        reviewers_ids = set(reviewers_ids)

        pull_request = self.__get_pull_request(pull_request)

        current_reviewers = PullRequestReviewers.query()\

                            .filter(PullRequestReviewers.pull_request==

                                   pull_request)\

                            .all()

        current_reviewers_ids = set([x.user.user_id for x in current_reviewers])

        to_add = reviewers_ids.difference(current_reviewers_ids)

        to_remove = current_reviewers_ids.difference(reviewers_ids)

        log.debug("Adding %s reviewers" % to_add)

        log.debug("Removing %s reviewers" % to_remove)

        for uid in to_add:

            _usr = self._get_user(uid)

            reviewer = PullRequestReviewers(_usr, pull_request)

            self.sa.add(reviewer)

        for uid in to_remove:

            reviewer = PullRequestReviewers.query()\

                    .filter(PullRequestReviewers.user_id==uid,

                            PullRequestReviewers.pull_request==pull_request)\

                    .scalar()

            if reviewer:

                self.sa.delete(reviewer)

    def delete(self, pull_request):

        pull_request = self.__get_pull_request(pull_request)

        Session().delete(pull_request)

    def close_pull_request(self, pull_request):

        pull_request = self.__get_pull_request(pull_request)

        pull_request.status = PullRequest.STATUS_CLOSED

        pull_request.updated_on = datetime.datetime.now()

        self.sa.add(pull_request)

    def _get_changesets(self, alias, org_repo, org_ref, other_repo, other_ref):

        """

        Returns a list of changesets that can be merged from org_repo@org_ref

        to other_repo@other_ref ... and the ancestor that would be used for merge

<div class="pullrequests_section_head">${_('Opened by me')}</div>

<ul>

    %if c.my_pull_requests:

      %for pull_request in c.my_pull_requests:

      <li>

        <div style="height: 12px">

          <div style="float:left">

          <a href="${h.url('pullrequest_show',repo_name=pull_request.other_repo.repo_name,pull_request_id=pull_request.pull_request_id)}">

          ${_('Pull request #%s opened on %s') % (pull_request.pull_request_id, h.fmt_date(pull_request.created_on))}

          </a>

          </div>

          <div style="float:left;margin-top: -5px">

            ${h.form(url('pullrequest_delete', repo_name=pull_request.other_repo.repo_name, pull_request_id=pull_request.pull_request_id),method='delete')}

              ${h.submit('remove_%s' % pull_request.pull_request_id,'',class_="delete_icon action_button",onclick="return confirm('"+_('Confirm to delete this pull request')+"');")}

            ${h.end_form()}

          </div>

        </div>

      </li>

      %endfor

   %else:

    <li><span class="empty_data">${_('Nothing here yet')}</span></li>

   %endif

</ul>

<div class="pullrequests_section_head" style="clear:both">${_('I participate in')}</div>

<ul>

    %if c.participate_in_pull_requests:

      %for pull_request in c.participate_in_pull_requests:

      <li>

        <div style="height: 12px">

        <a href="${h.url('pullrequest_show',repo_name=pull_request.other_repo.repo_name,pull_request_id=pull_request.pull_request_id)}">

        ${_('Pull request #%s opened by %s on %s') % (pull_request.pull_request_id, pull_request.author.full_name, h.fmt_date(pull_request.created_on))}

        </a>

      </div>

      </li>

      %endfor

    %else:

     <li><span class="empty_data">${_('Nothing here yet')}</span></li>

    %endif

</ul>