reviewers: added observers as another way to define reviewers.

- fixes  #4183

rhodecode/lib/dbmigrate/versions/110_version_4_22_0.py

@@ -0,0 +1,68 b''
+# -*- coding: utf-8 -*-
+
+import logging
+from sqlalchemy import *
+
+from alembic.migration import MigrationContext
+from alembic.operations import Operations
+
+from rhodecode.lib.dbmigrate.versions import _reset_base
+from rhodecode.model import meta, init_model_encryption
+
+
+log = logging.getLogger(__name__)
+
+
+def upgrade(migrate_engine):
+    """
+    Upgrade operations go here.
+    Don't create your own engine; bind migrate_engine to your metadata
+    """
+    _reset_base(migrate_engine)
+    from rhodecode.lib.dbmigrate.schema import db_4_20_0_0 as db
+
+    init_model_encryption(db)
+
+    context = MigrationContext.configure(migrate_engine.connect())
+    op = Operations(context)
+
+    table = db.RepoReviewRuleUser.__table__
+    with op.batch_alter_table(table.name) as batch_op:
+        new_column = Column('role', Unicode(255), nullable=True)
+        batch_op.add_column(new_column)
+
+    _fill_rule_user_role(op, meta.Session)
+
+    table = db.RepoReviewRuleUserGroup.__table__
+    with op.batch_alter_table(table.name) as batch_op:
+        new_column = Column('role', Unicode(255), nullable=True)
+        batch_op.add_column(new_column)
+
+    _fill_rule_user_group_role(op, meta.Session)
+
+
+def downgrade(migrate_engine):
+    meta = MetaData()
+    meta.bind = migrate_engine
+
+
+def fixups(models, _SESSION):
+    pass
+
+
+def _fill_rule_user_role(op, session):
+    params = {'role': 'reviewer'}
+    query = text(
+        'UPDATE repo_review_rules_users SET role = :role'
+    ).bindparams(**params)
+    op.execute(query)
+    session().commit()
+
+
+def _fill_rule_user_group_role(op, session):
+    params = {'role': 'reviewer'}
+    query = text(
+        'UPDATE repo_review_rules_users_groups SET role = :role'
+    ).bindparams(**params)
+    op.execute(query)
+    session().commit()

rhodecode/lib/string_renderer.py

@@ -0,0 +1,35 b''
+# -*- coding: utf-8 -*-
+
+# Copyright (C) 2010-2020 RhodeCode GmbH
+#
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU Affero General Public License, version 3
+# (only), as published by the Free Software Foundation.
+#
+# 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 Affero General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+#
+# This program is dual-licensed. If you wish to learn more about the
+# RhodeCode Enterprise Edition, including its added features, Support services,
+# and proprietary license terms, please see https://rhodecode.com/licenses/
+
+
+def html(info):
+    """
+    Custom string as html content_type renderer for pyramid
+    """
+    def _render(value, system):
+        request = system.get('request')
+        if request is not None:
+            response = request.response
+            ct = response.content_type
+            if ct == response.default_content_type:
+                response.content_type = 'text/html'
+        return value
+
+    return _render

rhodecode/__init__.py

@@ -1,60 +1,60 b''
 # -*- coding: utf-8 -*-
 
 # Copyright (C) 2010-2020 RhodeCode GmbH
 #
 # This program is free software: you can redistribute it and/or modify
 # it under the terms of the GNU Affero General Public License, version 3
 # (only), as published by the Free Software Foundation.
 #
 # 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 Affero General Public License
 # along with this program.  If not, see <http://www.gnu.org/licenses/>.
 #
 # This program is dual-licensed. If you wish to learn more about the
 # RhodeCode Enterprise Edition, including its added features, Support services,
 # and proprietary license terms, please see https://rhodecode.com/licenses/
 
 import os
 from collections import OrderedDict
 
 import sys
 import platform
 
 VERSION = tuple(open(os.path.join(
     os.path.dirname(__file__), 'VERSION')).read().split('.'))
 
 BACKENDS = OrderedDict()
 
 BACKENDS['hg'] = 'Mercurial repository'
 BACKENDS['git'] = 'Git repository'
 BACKENDS['svn'] = 'Subversion repository'
 
 
 CELERY_ENABLED = False
 CELERY_EAGER = False
 
 # link to config for pyramid
 CONFIG = {}
 
 # Populated with the settings dictionary from application init in
 # rhodecode.conf.environment.load_pyramid_environment
 PYRAMID_SETTINGS = {}
 
 # Linked module for extensions
 EXTENSIONS = {}
 
 __version__ = ('.'.join((str(each) for each in VERSION[:3])))
-__dbversion__ = 109  # defines current db version for migrations
+__dbversion__ = 110  # defines current db version for migrations
 __platform__ = platform.system()
 __license__ = 'AGPLv3, and Commercial License'
 __author__ = 'RhodeCode GmbH'
 __url__ = 'https://code.rhodecode.com'
 
 is_windows = __platform__ in ['Windows']
 is_unix = not is_windows
 is_test = False
 disable_error_handler = False

rhodecode/api/views/pull_request_api.py

@@ -1,1018 +1,1017 b''
 # -*- coding: utf-8 -*-
 
 # Copyright (C) 2011-2020 RhodeCode GmbH
 #
 # This program is free software: you can redistribute it and/or modify
 # it under the terms of the GNU Affero General Public License, version 3
 # (only), as published by the Free Software Foundation.
 #
 # 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 Affero General Public License
 # along with this program.  If not, see <http://www.gnu.org/licenses/>.
 #
 # This program is dual-licensed. If you wish to learn more about the
 # RhodeCode Enterprise Edition, including its added features, Support services,
 # and proprietary license terms, please see https://rhodecode.com/licenses/
 
 
 import logging
 
 from rhodecode.api import jsonrpc_method, JSONRPCError, JSONRPCValidationError
 from rhodecode.api.utils import (
     has_superadmin_permission, Optional, OAttr, get_repo_or_error,
     get_pull_request_or_error, get_commit_or_error, get_user_or_error,
     validate_repo_permissions, resolve_ref_or_error, validate_set_owner_permissions)
 from rhodecode.lib.auth import (HasRepoPermissionAnyApi)
 from rhodecode.lib.base import vcs_operation_context
 from rhodecode.lib.utils2 import str2bool
 from rhodecode.model.changeset_status import ChangesetStatusModel
 from rhodecode.model.comment import CommentsModel
 from rhodecode.model.db import Session, ChangesetStatus, ChangesetComment, PullRequest
 from rhodecode.model.pull_request import PullRequestModel, MergeCheck
 from rhodecode.model.settings import SettingsModel
 from rhodecode.model.validation_schema import Invalid
 from rhodecode.model.validation_schema.schemas.reviewer_schema import ReviewerListSchema
 
 log = logging.getLogger(__name__)
 
 
 @jsonrpc_method()
 def get_pull_request(request, apiuser, pullrequestid, repoid=Optional(None),
                      merge_state=Optional(False)):
     """
     Get a pull request based on the given ID.
 
     :param apiuser: This is filled automatically from the |authtoken|.
     :type apiuser: AuthUser
     :param repoid: Optional, repository name or repository ID from where
         the pull request was opened.
     :type repoid: str or int
     :param pullrequestid: ID of the requested pull request.
     :type pullrequestid: int
     :param merge_state: Optional calculate merge state for each repository.
         This could result in longer time to fetch the data
     :type merge_state: bool
 
     Example output:
 
     .. code-block:: bash
 
       "id": <id_given_in_input>,
       "result":
         {
             "pull_request_id":   "<pull_request_id>",
             "url":               "<url>",
             "title":             "<title>",
             "description":       "<description>",
             "status" :           "<status>",
             "created_on":        "<date_time_created>",
             "updated_on":        "<date_time_updated>",
             "versions":          "<number_or_versions_of_pr>",
             "commit_ids":        [
                                      ...
                                      "<commit_id>",
                                      "<commit_id>",
                                      ...
                                  ],
             "review_status":    "<review_status>",
             "mergeable":         {
                                      "status":  "<bool>",
                                      "message": "<message>",
                                  },
             "source":            {
                                      "clone_url":     "<clone_url>",
                                      "repository":    "<repository_name>",
                                      "reference":
                                      {
                                          "name":      "<name>",
                                          "type":      "<type>",
                                          "commit_id": "<commit_id>",
                                      }
                                  },
             "target":            {
                                      "clone_url":   "<clone_url>",
                                      "repository":    "<repository_name>",
                                      "reference":
                                      {
                                          "name":      "<name>",
                                          "type":      "<type>",
                                          "commit_id": "<commit_id>",
                                      }
                                  },
             "merge":             {
                                      "clone_url":   "<clone_url>",
                                      "reference":
                                      {
                                          "name":      "<name>",
                                          "type":      "<type>",
                                          "commit_id": "<commit_id>",
                                      }
                                  },
            "author":             <user_obj>,
            "reviewers":          [
                                      ...
                                      {
                                         "user":          "<user_obj>",
                                         "review_status": "<review_status>",
                                      }
                                      ...
                                  ]
         },
        "error": null
     """
 
     pull_request = get_pull_request_or_error(pullrequestid)
     if Optional.extract(repoid):
         repo = get_repo_or_error(repoid)
     else:
         repo = pull_request.target_repo
 
     if not PullRequestModel().check_user_read(pull_request, apiuser, api=True):
         raise JSONRPCError('repository `%s` or pull request `%s` '
                            'does not exist' % (repoid, pullrequestid))
 
     # NOTE(marcink): only calculate and return merge state if the pr state is 'created'
     # otherwise we can lock the repo on calculation of merge state while update/merge
     # is happening.
     pr_created = pull_request.pull_request_state == pull_request.STATE_CREATED
     merge_state = Optional.extract(merge_state, binary=True) and pr_created
     data = pull_request.get_api_data(with_merge_state=merge_state)
     return data
 
 
 @jsonrpc_method()
 def get_pull_requests(request, apiuser, repoid, status=Optional('new'),
                       merge_state=Optional(False)):
     """
     Get all pull requests from the repository specified in `repoid`.
 
     :param apiuser: This is filled automatically from the |authtoken|.
     :type apiuser: AuthUser
     :param repoid: Optional repository name or repository ID.
     :type repoid: str or int
     :param status: Only return pull requests with the specified status.
         Valid options are.
         * ``new`` (default)
         * ``open``
         * ``closed``
     :type status: str
     :param merge_state: Optional calculate merge state for each repository.
         This could result in longer time to fetch the data
     :type merge_state: bool
 
     Example output:
 
     .. code-block:: bash
 
       "id": <id_given_in_input>,
       "result":
         [
             ...
             {
                 "pull_request_id":   "<pull_request_id>",
                 "url":               "<url>",
                 "title" :            "<title>",
                 "description":       "<description>",
                 "status":            "<status>",
                 "created_on":        "<date_time_created>",
                 "updated_on":        "<date_time_updated>",
                 "commit_ids":        [
                                          ...
                                          "<commit_id>",
                                          "<commit_id>",
                                          ...
                                      ],
                 "review_status":    "<review_status>",
                 "mergeable":         {
                                         "status":      "<bool>",
                                         "message:      "<message>",
                                      },
                 "source":            {
                                          "clone_url":     "<clone_url>",
                                          "reference":
                                          {
                                              "name":      "<name>",
                                              "type":      "<type>",
                                              "commit_id": "<commit_id>",
                                          }
                                      },
                 "target":            {
                                          "clone_url":   "<clone_url>",
                                          "reference":
                                          {
                                              "name":      "<name>",
                                              "type":      "<type>",
                                              "commit_id": "<commit_id>",
                                          }
                                      },
                 "merge":             {
                                          "clone_url":   "<clone_url>",
                                          "reference":
                                          {
                                              "name":      "<name>",
                                              "type":      "<type>",
                                              "commit_id": "<commit_id>",
                                          }
                                      },
                "author":             <user_obj>,
                "reviewers":          [
                                          ...
                                          {
                                             "user":          "<user_obj>",
                                             "review_status": "<review_status>",
                                          }
                                          ...
                                      ]
             }
             ...
         ],
       "error": null
 
     """
     repo = get_repo_or_error(repoid)
     if not has_superadmin_permission(apiuser):
         _perms = (
             'repository.admin', 'repository.write', 'repository.read',)
         validate_repo_permissions(apiuser, repoid, repo, _perms)
 
     status = Optional.extract(status)
     merge_state = Optional.extract(merge_state, binary=True)
     pull_requests = PullRequestModel().get_all(repo, statuses=[status],
                                                order_by='id', order_dir='desc')
     data = [pr.get_api_data(with_merge_state=merge_state) for pr in pull_requests]
     return data
 
 
 @jsonrpc_method()
 def merge_pull_request(
         request, apiuser, pullrequestid, repoid=Optional(None),
         userid=Optional(OAttr('apiuser'))):
     """
     Merge the pull request specified by `pullrequestid` into its target
     repository.
 
     :param apiuser: This is filled automatically from the |authtoken|.
     :type apiuser: AuthUser
     :param repoid: Optional, repository name or repository ID of the
         target repository to which the |pr| is to be merged.
     :type repoid: str or int
     :param pullrequestid: ID of the pull request which shall be merged.
     :type pullrequestid: int
     :param userid: Merge the pull request as this user.
     :type userid: Optional(str or int)
 
     Example output:
 
     .. code-block:: bash
 
         "id": <id_given_in_input>,
         "result": {
             "executed":               "<bool>",
             "failure_reason":         "<int>",
             "merge_status_message":   "<str>",
             "merge_commit_id":        "<merge_commit_id>",
             "possible":               "<bool>",
             "merge_ref":        {
                                     "commit_id": "<commit_id>",
                                     "type":      "<type>",
                                     "name":      "<name>"
                                 }
         },
         "error": null
     """
     pull_request = get_pull_request_or_error(pullrequestid)
     if Optional.extract(repoid):
         repo = get_repo_or_error(repoid)
     else:
         repo = pull_request.target_repo
     auth_user = apiuser
 
     if not isinstance(userid, Optional):
         is_repo_admin = HasRepoPermissionAnyApi('repository.admin')(
             user=apiuser, repo_name=repo.repo_name)
         if has_superadmin_permission(apiuser) or is_repo_admin:
             apiuser = get_user_or_error(userid)
             auth_user = apiuser.AuthUser()
         else:
             raise JSONRPCError('userid is not the same as your user')
 
     if pull_request.pull_request_state != PullRequest.STATE_CREATED:
         raise JSONRPCError(
             'Operation forbidden because pull request is in state {}, '
             'only state {} is allowed.'.format(
                 pull_request.pull_request_state, PullRequest.STATE_CREATED))
 
     with pull_request.set_state(PullRequest.STATE_UPDATING):
         check = MergeCheck.validate(pull_request, auth_user=auth_user,
                                     translator=request.translate)
     merge_possible = not check.failed
 
     if not merge_possible:
         error_messages = []
         for err_type, error_msg in check.errors:
             error_msg = request.translate(error_msg)
             error_messages.append(error_msg)
 
         reasons = ','.join(error_messages)
         raise JSONRPCError(
             'merge not possible for following reasons: {}'.format(reasons))
 
     target_repo = pull_request.target_repo
     extras = vcs_operation_context(
         request.environ, repo_name=target_repo.repo_name,
         username=auth_user.username, action='push',
         scm=target_repo.repo_type)
     with pull_request.set_state(PullRequest.STATE_UPDATING):
         merge_response = PullRequestModel().merge_repo(
             pull_request, apiuser, extras=extras)
     if merge_response.executed:
         PullRequestModel().close_pull_request(pull_request.pull_request_id, auth_user)
 
         Session().commit()
 
     # In previous versions the merge response directly contained the merge
     # commit id. It is now contained in the merge reference object. To be
     # backwards compatible we have to extract it again.
     merge_response = merge_response.asdict()
     merge_response['merge_commit_id'] = merge_response['merge_ref'].commit_id
 
     return merge_response
 
 
 @jsonrpc_method()
 def get_pull_request_comments(
         request, apiuser, pullrequestid, repoid=Optional(None)):
     """
     Get all comments of pull request specified with the `pullrequestid`
 
     :param apiuser: This is filled automatically from the |authtoken|.
     :type apiuser: AuthUser
     :param repoid: Optional repository name or repository ID.
     :type repoid: str or int
     :param pullrequestid: The pull request ID.
     :type pullrequestid: int
 
     Example output:
 
     .. code-block:: bash
 
         id : <id_given_in_input>
         result : [
             {
               "comment_author": {
                 "active": true,
                 "full_name_or_username": "Tom Gore",
                 "username": "admin"
               },
               "comment_created_on": "2017-01-02T18:43:45.533",
               "comment_f_path": null,
               "comment_id": 25,
               "comment_lineno": null,
               "comment_status": {
                 "status": "under_review",
                 "status_lbl": "Under Review"
               },
               "comment_text": "Example text",
               "comment_type": null,
               "comment_last_version: 0,
               "pull_request_version": null,
               "comment_commit_id": None,
               "comment_pull_request_id": <pull_request_id>
             }
         ],
         error :  null
     """
 
     pull_request = get_pull_request_or_error(pullrequestid)
     if Optional.extract(repoid):
         repo = get_repo_or_error(repoid)
     else:
         repo = pull_request.target_repo
 
     if not PullRequestModel().check_user_read(
             pull_request, apiuser, api=True):
         raise JSONRPCError('repository `%s` or pull request `%s` '
                            'does not exist' % (repoid, pullrequestid))
 
     (pull_request_latest,
      pull_request_at_ver,
      pull_request_display_obj,
      at_version) = PullRequestModel().get_pr_version(
         pull_request.pull_request_id, version=None)
 
     versions = pull_request_display_obj.versions()
     ver_map = {
         ver.pull_request_version_id: cnt
         for cnt, ver in enumerate(versions, 1)
     }
 
     # GENERAL COMMENTS with versions #
     q = CommentsModel()._all_general_comments_of_pull_request(pull_request)
     q = q.order_by(ChangesetComment.comment_id.asc())
     general_comments = q.all()
 
     # INLINE COMMENTS with versions  #
     q = CommentsModel()._all_inline_comments_of_pull_request(pull_request)
     q = q.order_by(ChangesetComment.comment_id.asc())
     inline_comments = q.all()
 
     data = []
     for comment in inline_comments + general_comments:
         full_data = comment.get_api_data()
         pr_version_id = None
         if comment.pull_request_version_id:
             pr_version_id = 'v{}'.format(
                 ver_map[comment.pull_request_version_id])
 
         # sanitize some entries
 
         full_data['pull_request_version'] = pr_version_id
         full_data['comment_author'] = {
             'username': full_data['comment_author'].username,
             'full_name_or_username': full_data['comment_author'].full_name_or_username,
             'active': full_data['comment_author'].active,
         }
 
         if full_data['comment_status']:
             full_data['comment_status'] = {
                 'status': full_data['comment_status'][0].status,
                 'status_lbl': full_data['comment_status'][0].status_lbl,
             }
         else:
             full_data['comment_status'] = {}
 
         data.append(full_data)
     return data
 
 
 @jsonrpc_method()
 def comment_pull_request(
         request, apiuser, pullrequestid, repoid=Optional(None),
         message=Optional(None), commit_id=Optional(None), status=Optional(None),
         comment_type=Optional(ChangesetComment.COMMENT_TYPE_NOTE),
         resolves_comment_id=Optional(None), extra_recipients=Optional([]),
         userid=Optional(OAttr('apiuser')), send_email=Optional(True)):
     """
     Comment on the pull request specified with the `pullrequestid`,
     in the |repo| specified by the `repoid`, and optionally change the
     review status.
 
     :param apiuser: This is filled automatically from the |authtoken|.
     :type apiuser: AuthUser
     :param repoid: Optional repository name or repository ID.
     :type repoid: str or int
     :param pullrequestid: The pull request ID.
     :type pullrequestid: int
     :param commit_id: Specify the commit_id for which to set a comment. If
         given commit_id is different than latest in the PR status
         change won't be performed.
     :type commit_id: str
     :param message: The text content of the comment.
     :type message: str
     :param status: (**Optional**) Set the approval status of the pull
         request. One of: 'not_reviewed', 'approved', 'rejected',
         'under_review'
     :type status: str
     :param comment_type: Comment type, one of: 'note', 'todo'
     :type comment_type: Optional(str), default: 'note'
     :param resolves_comment_id: id of comment which this one will resolve
     :type resolves_comment_id: Optional(int)
     :param extra_recipients: list of user ids or usernames to add
         notifications for this comment. Acts like a CC for notification
     :type extra_recipients: Optional(list)
     :param userid: Comment on the pull request as this user
     :type userid: Optional(str or int)
     :param send_email: Define if this comment should also send email notification
     :type send_email: Optional(bool)
 
     Example output:
 
     .. code-block:: bash
 
         id : <id_given_in_input>
         result : {
             "pull_request_id":  "<Integer>",
             "comment_id":       "<Integer>",
             "status": {"given": <given_status>,
                        "was_changed": <bool status_was_actually_changed> },
         },
         error :  null
     """
     pull_request = get_pull_request_or_error(pullrequestid)
     if Optional.extract(repoid):
         repo = get_repo_or_error(repoid)
     else:
         repo = pull_request.target_repo
 
     auth_user = apiuser
     if not isinstance(userid, Optional):
         is_repo_admin = HasRepoPermissionAnyApi('repository.admin')(
             user=apiuser, repo_name=repo.repo_name)
         if has_superadmin_permission(apiuser) or is_repo_admin:
             apiuser = get_user_or_error(userid)
             auth_user = apiuser.AuthUser()
         else:
             raise JSONRPCError('userid is not the same as your user')
 
     if pull_request.is_closed():
         raise JSONRPCError(
             'pull request `%s` comment failed, pull request is closed' % (
                 pullrequestid,))
 
     if not PullRequestModel().check_user_read(
             pull_request, apiuser, api=True):
         raise JSONRPCError('repository `%s` does not exist' % (repoid,))
     message = Optional.extract(message)
     status = Optional.extract(status)
     commit_id = Optional.extract(commit_id)
     comment_type = Optional.extract(comment_type)
     resolves_comment_id = Optional.extract(resolves_comment_id)
     extra_recipients = Optional.extract(extra_recipients)
     send_email = Optional.extract(send_email, binary=True)
 
     if not message and not status:
         raise JSONRPCError(
             'Both message and status parameters are missing. '
             'At least one is required.')
 
     if (status not in (st[0] for st in ChangesetStatus.STATUSES) and
             status is not None):
         raise JSONRPCError('Unknown comment status: `%s`' % status)
 
     if commit_id and commit_id not in pull_request.revisions:
         raise JSONRPCError(
             'Invalid commit_id `%s` for this pull request.' % commit_id)
 
     allowed_to_change_status = PullRequestModel().check_user_change_status(
         pull_request, apiuser)
 
     # if commit_id is passed re-validated if user is allowed to change status
     # based on latest commit_id from the PR
     if commit_id:
         commit_idx = pull_request.revisions.index(commit_id)
         if commit_idx != 0:
             allowed_to_change_status = False
 
     if resolves_comment_id:
         comment = ChangesetComment.get(resolves_comment_id)
         if not comment:
             raise JSONRPCError(
                 'Invalid resolves_comment_id `%s` for this pull request.'
                 % resolves_comment_id)
         if comment.comment_type != ChangesetComment.COMMENT_TYPE_TODO:
             raise JSONRPCError(
                 'Comment `%s` is wrong type for setting status to resolved.'
                 % resolves_comment_id)
 
     text = message
     status_label = ChangesetStatus.get_status_lbl(status)
     if status and allowed_to_change_status:
         st_message = ('Status change %(transition_icon)s %(status)s'
                       % {'transition_icon': '>', 'status': status_label})
         text = message or st_message
 
     rc_config = SettingsModel().get_all_settings()
     renderer = rc_config.get('rhodecode_markup_renderer', 'rst')
 
     status_change = status and allowed_to_change_status
     comment = CommentsModel().create(
         text=text,
         repo=pull_request.target_repo.repo_id,
         user=apiuser.user_id,
         pull_request=pull_request.pull_request_id,
         f_path=None,
         line_no=None,
         status_change=(status_label if status_change else None),
         status_change_type=(status if status_change else None),
         closing_pr=False,
         renderer=renderer,
         comment_type=comment_type,
         resolves_comment_id=resolves_comment_id,
         auth_user=auth_user,
         extra_recipients=extra_recipients,
         send_email=send_email
     )
 
     if allowed_to_change_status and status:
         old_calculated_status = pull_request.calculated_review_status()
         ChangesetStatusModel().set_status(
             pull_request.target_repo.repo_id,
             status,
             apiuser.user_id,
             comment,
             pull_request=pull_request.pull_request_id
         )
         Session().flush()
 
     Session().commit()
 
     PullRequestModel().trigger_pull_request_hook(
         pull_request, apiuser, 'comment',
         data={'comment': comment})
 
     if allowed_to_change_status and status:
         # we now calculate the status of pull request, and based on that
         # calculation we set the commits status
         calculated_status = pull_request.calculated_review_status()
         if old_calculated_status != calculated_status:
             PullRequestModel().trigger_pull_request_hook(
                 pull_request, apiuser, 'review_status_change',
                 data={'status': calculated_status})
 
     data = {
         'pull_request_id': pull_request.pull_request_id,
         'comment_id': comment.comment_id if comment else None,
         'status': {'given': status, 'was_changed': status_change},
     }
     return data
 
 
 @jsonrpc_method()
 def create_pull_request(
         request, apiuser, source_repo, target_repo, source_ref, target_ref,
         owner=Optional(OAttr('apiuser')), title=Optional(''), description=Optional(''),
         description_renderer=Optional(''), reviewers=Optional(None)):
     """
     Creates a new pull request.
 
     Accepts refs in the following formats:
 
         * branch:<branch_name>:<sha>
         * branch:<branch_name>
         * bookmark:<bookmark_name>:<sha> (Mercurial only)
         * bookmark:<bookmark_name> (Mercurial only)
 
     :param apiuser: This is filled automatically from the |authtoken|.
     :type apiuser: AuthUser
     :param source_repo: Set the source repository name.
     :type source_repo: str
     :param target_repo: Set the target repository name.
     :type target_repo: str
     :param source_ref: Set the source ref name.
     :type source_ref: str
     :param target_ref: Set the target ref name.
     :type target_ref: str
     :param owner: user_id or username
     :type owner: Optional(str)
     :param title: Optionally Set the pull request title, it's generated otherwise
     :type title: str
     :param description: Set the pull request description.
     :type description: Optional(str)
     :type description_renderer: Optional(str)
     :param description_renderer: Set pull request renderer for the description.
         It should be 'rst', 'markdown' or 'plain'. If not give default
         system renderer will be used
     :param reviewers: Set the new pull request reviewers list.
         Reviewer defined by review rules will be added automatically to the
         defined list.
     :type reviewers: Optional(list)
         Accepts username strings or objects of the format:
 
             [{'username': 'nick', 'reasons': ['original author'], 'mandatory': <bool>}]
     """
 
     source_db_repo = get_repo_or_error(source_repo)
     target_db_repo = get_repo_or_error(target_repo)
     if not has_superadmin_permission(apiuser):
         _perms = ('repository.admin', 'repository.write', 'repository.read',)
         validate_repo_permissions(apiuser, source_repo, source_db_repo, _perms)
 
     owner = validate_set_owner_permissions(apiuser, owner)
 
     full_source_ref = resolve_ref_or_error(source_ref, source_db_repo)
     full_target_ref = resolve_ref_or_error(target_ref, target_db_repo)
 
     source_commit = get_commit_or_error(full_source_ref, source_db_repo)
     target_commit = get_commit_or_error(full_target_ref, target_db_repo)
 
     reviewer_objects = Optional.extract(reviewers) or []
 
     # serialize and validate passed in given reviewers
     if reviewer_objects:
         schema = ReviewerListSchema()
         try:
             reviewer_objects = schema.deserialize(reviewer_objects)
         except Invalid as err:
             raise JSONRPCValidationError(colander_exc=err)
 
         # validate users
         for reviewer_object in reviewer_objects:
             user = get_user_or_error(reviewer_object['username'])
             reviewer_object['user_id'] = user.user_id
 
-    get_default_reviewers_data, validate_default_reviewers = \
+    get_default_reviewers_data, validate_default_reviewers, validate_observers = \
         PullRequestModel().get_reviewer_functions()
 
     # recalculate reviewers logic, to make sure we can validate this
     default_reviewers_data = get_default_reviewers_data(
         owner, source_db_repo,
         source_commit, target_db_repo, target_commit)
 
     # now MERGE our given with the calculated
     reviewer_objects = default_reviewers_data['reviewers'] + reviewer_objects
 
     try:
         reviewers = validate_default_reviewers(
             reviewer_objects, default_reviewers_data)
     except ValueError as e:
         raise JSONRPCError('Reviewers Validation: {}'.format(e))
 
     title = Optional.extract(title)
     if not title:
         title_source_ref = source_ref.split(':', 2)[1]
         title = PullRequestModel().generate_pullrequest_title(
             source=source_repo,
             source_ref=title_source_ref,
             target=target_repo
         )
 
     diff_info = default_reviewers_data['diff_info']
     common_ancestor_id = diff_info['ancestor']
     commits = diff_info['commits']
 
     if not common_ancestor_id:
         raise JSONRPCError('no common ancestor found')
 
     if not commits:
         raise JSONRPCError('no commits found')
 
     # NOTE(marcink): reversed is consistent with how we open it in the WEB interface
     revisions = [commit.raw_id for commit in reversed(commits)]
 
     # recalculate target ref based on ancestor
     target_ref_type, target_ref_name, __ = full_target_ref.split(':')
     full_target_ref = ':'.join((target_ref_type, target_ref_name, common_ancestor_id))
 
     # fetch renderer, if set fallback to plain in case of PR
     rc_config = SettingsModel().get_all_settings()
     default_system_renderer = rc_config.get('rhodecode_markup_renderer', 'plain')
     description = Optional.extract(description)
     description_renderer = Optional.extract(description_renderer) or default_system_renderer
 
     pull_request = PullRequestModel().create(
         created_by=owner.user_id,
         source_repo=source_repo,
         source_ref=full_source_ref,
         target_repo=target_repo,
         target_ref=full_target_ref,
         common_ancestor_id=common_ancestor_id,
         revisions=revisions,
         reviewers=reviewers,
         title=title,
         description=description,
         description_renderer=description_renderer,
         reviewer_data=default_reviewers_data,
         auth_user=apiuser
     )
 
     Session().commit()
     data = {
         'msg': 'Created new pull request `{}`'.format(title),
         'pull_request_id': pull_request.pull_request_id,
     }
     return data
 
 
 @jsonrpc_method()
 def update_pull_request(
         request, apiuser, pullrequestid, repoid=Optional(None),
         title=Optional(''), description=Optional(''), description_renderer=Optional(''),
         reviewers=Optional(None), update_commits=Optional(None)):
     """
     Updates a pull request.
 
     :param apiuser: This is filled automatically from the |authtoken|.
     :type apiuser: AuthUser
     :param repoid: Optional repository name or repository ID.
     :type repoid: str or int
     :param pullrequestid: The pull request ID.
     :type pullrequestid: int
     :param title: Set the pull request title.
     :type title: str
     :param description: Update pull request description.
     :type description: Optional(str)
     :type description_renderer: Optional(str)
     :param description_renderer: Update pull request renderer for the description.
         It should be 'rst', 'markdown' or 'plain'
     :param reviewers: Update pull request reviewers list with new value.
     :type reviewers: Optional(list)
         Accepts username strings or objects of the format:
 
             [{'username': 'nick', 'reasons': ['original author'], 'mandatory': <bool>}]
 
     :param update_commits: Trigger update of commits for this pull request
     :type: update_commits: Optional(bool)
 
     Example output:
 
     .. code-block:: bash
 
         id : <id_given_in_input>
         result : {
             "msg": "Updated pull request `63`",
             "pull_request": <pull_request_object>,
             "updated_reviewers": {
               "added": [
                 "username"
               ],
               "removed": []
             },
             "updated_commits": {
               "added": [
                 "<sha1_hash>"
               ],
               "common": [
                 "<sha1_hash>",
                 "<sha1_hash>",
               ],
               "removed": []
             }
         }
         error :  null
     """
 
     pull_request = get_pull_request_or_error(pullrequestid)
     if Optional.extract(repoid):
         repo = get_repo_or_error(repoid)
     else:
         repo = pull_request.target_repo
 
     if not PullRequestModel().check_user_update(
             pull_request, apiuser, api=True):
         raise JSONRPCError(
             'pull request `%s` update failed, no permission to update.' % (
                 pullrequestid,))
     if pull_request.is_closed():
         raise JSONRPCError(
             'pull request `%s` update failed, pull request is closed' % (
                 pullrequestid,))
 
     reviewer_objects = Optional.extract(reviewers) or []
 
     if reviewer_objects:
         schema = ReviewerListSchema()
         try:
             reviewer_objects = schema.deserialize(reviewer_objects)
         except Invalid as err:
             raise JSONRPCValidationError(colander_exc=err)
 
         # validate users
         for reviewer_object in reviewer_objects:
             user = get_user_or_error(reviewer_object['username'])
             reviewer_object['user_id'] = user.user_id
 
-        get_default_reviewers_data, get_validated_reviewers = \
+        get_default_reviewers_data, get_validated_reviewers, validate_observers = \
             PullRequestModel().get_reviewer_functions()
 
         # re-use stored rules
         reviewer_rules = pull_request.reviewer_data
         try:
-            reviewers = get_validated_reviewers(
-                reviewer_objects, reviewer_rules)
+            reviewers = get_validated_reviewers(reviewer_objects, reviewer_rules)
         except ValueError as e:
             raise JSONRPCError('Reviewers Validation: {}'.format(e))
     else:
         reviewers = []
 
     title = Optional.extract(title)
     description = Optional.extract(description)
     description_renderer = Optional.extract(description_renderer)
 
     if title or description:
         PullRequestModel().edit(
             pull_request,
             title or pull_request.title,
             description or pull_request.description,
             description_renderer or pull_request.description_renderer,
             apiuser)
         Session().commit()
 
     commit_changes = {"added": [], "common": [], "removed": []}
     if str2bool(Optional.extract(update_commits)):
 
         if pull_request.pull_request_state != PullRequest.STATE_CREATED:
             raise JSONRPCError(
                 'Operation forbidden because pull request is in state {}, '
                 'only state {} is allowed.'.format(
                     pull_request.pull_request_state, PullRequest.STATE_CREATED))
 
         with pull_request.set_state(PullRequest.STATE_UPDATING):
             if PullRequestModel().has_valid_update_type(pull_request):
                 db_user = apiuser.get_instance()
                 update_response = PullRequestModel().update_commits(
                     pull_request, db_user)
                 commit_changes = update_response.changes or commit_changes
             Session().commit()
 
     reviewers_changes = {"added": [], "removed": []}
     if reviewers:
         old_calculated_status = pull_request.calculated_review_status()
         added_reviewers, removed_reviewers = \
             PullRequestModel().update_reviewers(pull_request, reviewers, apiuser)
 
         reviewers_changes['added'] = sorted(
             [get_user_or_error(n).username for n in added_reviewers])
         reviewers_changes['removed'] = sorted(
             [get_user_or_error(n).username for n in removed_reviewers])
         Session().commit()
 
         # trigger status changed if change in reviewers changes the status
         calculated_status = pull_request.calculated_review_status()
         if old_calculated_status != calculated_status:
             PullRequestModel().trigger_pull_request_hook(
                 pull_request, apiuser, 'review_status_change',
                 data={'status': calculated_status})
 
     data = {
         'msg': 'Updated pull request `{}`'.format(
             pull_request.pull_request_id),
         'pull_request': pull_request.get_api_data(),
         'updated_commits': commit_changes,
         'updated_reviewers': reviewers_changes
     }
 
     return data
 
 
 @jsonrpc_method()
 def close_pull_request(
         request, apiuser, pullrequestid, repoid=Optional(None),
         userid=Optional(OAttr('apiuser')), message=Optional('')):
     """
     Close the pull request specified by `pullrequestid`.
 
     :param apiuser: This is filled automatically from the |authtoken|.
     :type apiuser: AuthUser
     :param repoid: Repository name or repository ID to which the pull
         request belongs.
     :type repoid: str or int
     :param pullrequestid: ID of the pull request to be closed.
     :type pullrequestid: int
     :param userid: Close the pull request as this user.
     :type userid: Optional(str or int)
     :param message: Optional message to close the Pull Request with. If not
         specified it will be generated automatically.
     :type message: Optional(str)
 
     Example output:
 
     .. code-block:: bash
 
         "id": <id_given_in_input>,
         "result": {
             "pull_request_id":  "<int>",
             "close_status":     "<str:status_lbl>,
             "closed":           "<bool>"
         },
         "error": null
 
     """
     _ = request.translate
 
     pull_request = get_pull_request_or_error(pullrequestid)
     if Optional.extract(repoid):
         repo = get_repo_or_error(repoid)
     else:
         repo = pull_request.target_repo
 
     is_repo_admin = HasRepoPermissionAnyApi('repository.admin')(
                     user=apiuser, repo_name=repo.repo_name)
     if not isinstance(userid, Optional):
         if has_superadmin_permission(apiuser) or is_repo_admin:
             apiuser = get_user_or_error(userid)
         else:
             raise JSONRPCError('userid is not the same as your user')
 
     if pull_request.is_closed():
         raise JSONRPCError(
             'pull request `%s` is already closed' % (pullrequestid,))
 
     # only owner or admin or person with write permissions
     allowed_to_close = PullRequestModel().check_user_update(
             pull_request, apiuser, api=True)
 
     if not allowed_to_close:
         raise JSONRPCError(
             'pull request `%s` close failed, no permission to close.' % (
                 pullrequestid,))
 
     # message we're using to close the PR, else it's automatically generated
     message = Optional.extract(message)
 
     # finally close the PR, with proper message comment
     comment, status = PullRequestModel().close_pull_request_with_comment(
         pull_request, apiuser, repo, message=message, auth_user=apiuser)
     status_lbl = ChangesetStatus.get_status_lbl(status)
 
     Session().commit()
 
     data = {
         'pull_request_id': pull_request.pull_request_id,
         'close_status': status_lbl,
         'closed': True,
     }
     return data

rhodecode/apps/debug_style/views.py

@@ -1,418 +1,486 b''
 # -*- coding: utf-8 -*-
 
 # Copyright (C) 2016-2020 RhodeCode GmbH
 #
 # This program is free software: you can redistribute it and/or modify
 # it under the terms of the GNU Affero General Public License, version 3
 # (only), as published by the Free Software Foundation.
 #
 # 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 Affero General Public License
 # along with this program.  If not, see <http://www.gnu.org/licenses/>.
 #
 # This program is dual-licensed. If you wish to learn more about the
 # RhodeCode Enterprise Edition, including its added features, Support services,
 # and proprietary license terms, please see https://rhodecode.com/licenses/
 
 import os
 import logging
 import datetime
 
 from pyramid.view import view_config
 from pyramid.renderers import render_to_response
 from rhodecode.apps._base import BaseAppView
 from rhodecode.lib.celerylib import run_task, tasks
 from rhodecode.lib.utils2 import AttributeDict
 from rhodecode.model.db import User
 from rhodecode.model.notification import EmailNotificationModel
 
 log = logging.getLogger(__name__)
 
 
 class DebugStyleView(BaseAppView):
+
     def load_default_context(self):
         c = self._get_local_tmpl_context()
 
         return c
 
     @view_config(
         route_name='debug_style_home', request_method='GET',
         renderer=None)
     def index(self):
         c = self.load_default_context()
         c.active = 'index'
 
         return render_to_response(
             'debug_style/index.html', self._get_template_context(c),
             request=self.request)
 
     @view_config(
         route_name='debug_style_email', request_method='GET',
         renderer=None)
     @view_config(
         route_name='debug_style_email_plain_rendered', request_method='GET',
         renderer=None)
     def render_email(self):
         c = self.load_default_context()
         email_id = self.request.matchdict['email_id']
         c.active = 'emails'
 
         pr = AttributeDict(
             pull_request_id=123,
             title='digital_ocean: fix redis, elastic search start on boot, '
                   'fix fd limits on supervisor, set postgres 11 version',
             description='''
 Check if we should use full-topic or mini-topic.
 
 - full topic produces some problems with merge states etc
 - server-mini-topic needs probably tweeks.            
             ''',
             repo_name='foobar',
             source_ref_parts=AttributeDict(type='branch', name='fix-ticket-2000'),
             target_ref_parts=AttributeDict(type='branch', name='master'),
         )
+
         target_repo = AttributeDict(repo_name='repo_group/target_repo')
         source_repo = AttributeDict(repo_name='repo_group/source_repo')
         user = User.get_by_username(self.request.GET.get('user')) or self._rhodecode_db_user
         # file/commit changes for PR update
         commit_changes = AttributeDict({
             'added': ['aaaaaaabbbbb', 'cccccccddddddd'],
             'removed': ['eeeeeeeeeee'],
         })
+
         file_changes = AttributeDict({
             'added': ['a/file1.md', 'file2.py'],
             'modified': ['b/modified_file.rst'],
             'removed': ['.idea'],
         })
 
         exc_traceback = {
             'exc_utc_date': '2020-03-26T12:54:50.683281',
             'exc_id': 139638856342656,
             'exc_timestamp': '1585227290.683288',
             'version': 'v1',
             'exc_message': 'Traceback (most recent call last):\n  File "/nix/store/s43k2r9rysfbzmsjdqnxgzvvb7zjhkxb-python2.7-pyramid-1.10.4/lib/python2.7/site-packages/pyramid/tweens.py", line 41, in excview_tween\n    response = handler(request)\n  File "/nix/store/s43k2r9rysfbzmsjdqnxgzvvb7zjhkxb-python2.7-pyramid-1.10.4/lib/python2.7/site-packages/pyramid/router.py", line 148, in handle_request\n    registry, request, context, context_iface, view_name\n  File "/nix/store/s43k2r9rysfbzmsjdqnxgzvvb7zjhkxb-python2.7-pyramid-1.10.4/lib/python2.7/site-packages/pyramid/view.py", line 667, in _call_view\n    response = view_callable(context, request)\n  File "/nix/store/s43k2r9rysfbzmsjdqnxgzvvb7zjhkxb-python2.7-pyramid-1.10.4/lib/python2.7/site-packages/pyramid/config/views.py", line 188, in attr_view\n    return view(context, request)\n  File "/nix/store/s43k2r9rysfbzmsjdqnxgzvvb7zjhkxb-python2.7-pyramid-1.10.4/lib/python2.7/site-packages/pyramid/config/views.py", line 214, in predicate_wrapper\n    return view(context, request)\n  File "/nix/store/s43k2r9rysfbzmsjdqnxgzvvb7zjhkxb-python2.7-pyramid-1.10.4/lib/python2.7/site-packages/pyramid/viewderivers.py", line 401, in viewresult_to_response\n    result = view(context, request)\n  File "/nix/store/s43k2r9rysfbzmsjdqnxgzvvb7zjhkxb-python2.7-pyramid-1.10.4/lib/python2.7/site-packages/pyramid/viewderivers.py", line 132, in _class_view\n    response = getattr(inst, attr)()\n  File "/mnt/hgfs/marcink/workspace/rhodecode-enterprise-ce/rhodecode/apps/debug_style/views.py", line 355, in render_email\n    template_type, **email_kwargs.get(email_id, {}))\n  File "/mnt/hgfs/marcink/workspace/rhodecode-enterprise-ce/rhodecode/model/notification.py", line 402, in render_email\n    body = email_template.render(None, **_kwargs)\n  File "/mnt/hgfs/marcink/workspace/rhodecode-enterprise-ce/rhodecode/lib/partial_renderer.py", line 95, in render\n    return self._render_with_exc(tmpl, args, kwargs)\n  File "/mnt/hgfs/marcink/workspace/rhodecode-enterprise-ce/rhodecode/lib/partial_renderer.py", line 79, in _render_with_exc\n    return render_func.render(*args, **kwargs)\n  File "/nix/store/dakh34sxz4yfr435c0cwjz0sd6hnd5g3-python2.7-mako-1.1.0/lib/python2.7/site-packages/mako/template.py", line 476, in render\n    return runtime._render(self, self.callable_, args, data)\n  File "/nix/store/dakh34sxz4yfr435c0cwjz0sd6hnd5g3-python2.7-mako-1.1.0/lib/python2.7/site-packages/mako/runtime.py", line 883, in _render\n    **_kwargs_for_callable(callable_, data)\n  File "/nix/store/dakh34sxz4yfr435c0cwjz0sd6hnd5g3-python2.7-mako-1.1.0/lib/python2.7/site-packages/mako/runtime.py", line 920, in _render_context\n    _exec_template(inherit, lclcontext, args=args, kwargs=kwargs)\n  File "/nix/store/dakh34sxz4yfr435c0cwjz0sd6hnd5g3-python2.7-mako-1.1.0/lib/python2.7/site-packages/mako/runtime.py", line 947, in _exec_template\n    callable_(context, *args, **kwargs)\n  File "rhodecode_templates_email_templates_base_mako", line 63, in render_body\n  File "rhodecode_templates_email_templates_exception_tracker_mako", line 43, in render_body\nAttributeError: \'str\' object has no attribute \'get\'\n',
             'exc_type': 'AttributeError'
         }
+
         email_kwargs = {
             'test': {},
+
             'message': {
                 'body': 'message body !'
             },
+
             'email_test': {
                 'user': user,
                 'date': datetime.datetime.now(),
             },
+
             'exception': {
                 'email_prefix': '[RHODECODE ERROR]',
                 'exc_id': exc_traceback['exc_id'],
                 'exc_url': 'http://server-url/{}'.format(exc_traceback['exc_id']),
                 'exc_type_name': 'NameError',
                 'exc_traceback': exc_traceback,
             },
+
             'password_reset': {
                 'password_reset_url': 'http://example.com/reset-rhodecode-password/token',
 
                 'user': user,
                 'date': datetime.datetime.now(),
                 'email': '[e-mail]',
                 'first_admin_email': User.get_first_super_admin().email
             },
+
             'password_reset_confirmation': {
                 'new_password': 'new-password-example',
                 'user': user,
                 'date': datetime.datetime.now(),
                 'email': '[e-mail]',
                 'first_admin_email': User.get_first_super_admin().email
             },
+
             'registration': {
                 'user': user,
                 'date': datetime.datetime.now(),
             },
 
             'pull_request_comment': {
                 'user': user,
 
                 'status_change': None,
                 'status_change_type': None,
 
                 'pull_request': pr,
                 'pull_request_commits': [],
 
                 'pull_request_target_repo': target_repo,
                 'pull_request_target_repo_url': 'http://target-repo/url',
 
                 'pull_request_source_repo': source_repo,
                 'pull_request_source_repo_url': 'http://source-repo/url',
 
                 'pull_request_url': 'http://localhost/pr1',
                 'pr_comment_url': 'http://comment-url',
                 'pr_comment_reply_url': 'http://comment-url#reply',
 
                 'comment_file': None,
                 'comment_line': None,
                 'comment_type': 'note',
                 'comment_body': 'This is my comment body. *I like !*',
                 'comment_id': 2048,
                 'renderer_type': 'markdown',
                 'mention': True,
 
             },
+
             'pull_request_comment+status': {
                 'user': user,
 
                 'status_change': 'approved',
                 'status_change_type': 'approved',
 
                 'pull_request': pr,
                 'pull_request_commits': [],
 
                 'pull_request_target_repo': target_repo,
                 'pull_request_target_repo_url': 'http://target-repo/url',
 
                 'pull_request_source_repo': source_repo,
                 'pull_request_source_repo_url': 'http://source-repo/url',
 
                 'pull_request_url': 'http://localhost/pr1',
                 'pr_comment_url': 'http://comment-url',
                 'pr_comment_reply_url': 'http://comment-url#reply',
 
                 'comment_type': 'todo',
                 'comment_file': None,
                 'comment_line': None,
                 'comment_body': '''
 I think something like this would be better
 
 ```py
 // markdown renderer
 
 def db():
    global connection
    return connection
 
 ```
                 
                 ''',
                 'comment_id': 2048,
                 'renderer_type': 'markdown',
                 'mention': True,
 
             },
+
             'pull_request_comment+file': {
                 'user': user,
 
                 'status_change': None,
                 'status_change_type': None,
 
                 'pull_request': pr,
                 'pull_request_commits': [],
 
                 'pull_request_target_repo': target_repo,
                 'pull_request_target_repo_url': 'http://target-repo/url',
 
                 'pull_request_source_repo': source_repo,
                 'pull_request_source_repo_url': 'http://source-repo/url',
 
                 'pull_request_url': 'http://localhost/pr1',
 
                 'pr_comment_url': 'http://comment-url',
                 'pr_comment_reply_url': 'http://comment-url#reply',
 
                 'comment_file': 'rhodecode/model/get_flow_commits',
                 'comment_line': 'o1210',
                 'comment_type': 'todo',
                 'comment_body': '''
 I like this !
 
 But please check this code
 
 .. code-block:: javascript
 
   // THIS IS RST CODE
 
   this.createResolutionComment = function(commentId) {
     // hide the trigger text
     $('#resolve-comment-{0}'.format(commentId)).hide();
 
     var comment = $('#comment-'+commentId);
     var commentData = comment.data();
     if (commentData.commentInline) {
         this.createComment(comment, commentId)
     } else {
         Rhodecode.comments.createGeneralComment('general', "$placeholder", commentId)
     }
 
     return false;
   };
 
 This should work better !
                 ''',
                 'comment_id': 2048,
                 'renderer_type': 'rst',
                 'mention': True,
 
             },
 
             'pull_request_update': {
                 'updating_user': user,
 
                 'status_change': None,
                 'status_change_type': None,
 
                 'pull_request': pr,
                 'pull_request_commits': [],
 
                 'pull_request_target_repo': target_repo,
                 'pull_request_target_repo_url': 'http://target-repo/url',
 
                 'pull_request_source_repo': source_repo,
                 'pull_request_source_repo_url': 'http://source-repo/url',
 
                 'pull_request_url': 'http://localhost/pr1',
 
                 # update comment links
                 'pr_comment_url': 'http://comment-url',
                 'pr_comment_reply_url': 'http://comment-url#reply',
                 'ancestor_commit_id': 'f39bd443',
                 'added_commits': commit_changes.added,
                 'removed_commits': commit_changes.removed,
                 'changed_files': (file_changes.added + file_changes.modified + file_changes.removed),
                 'added_files': file_changes.added,
                 'modified_files': file_changes.modified,
                 'removed_files': file_changes.removed,
             },
 
             'cs_comment': {
                 'user': user,
                 'commit': AttributeDict(idx=123, raw_id='a'*40, message='Commit message'),
                 'status_change': None,
                 'status_change_type': None,
 
                 'commit_target_repo_url': 'http://foo.example.com/#comment1',
                 'repo_name': 'test-repo',
                 'comment_type': 'note',
                 'comment_file': None,
                 'comment_line': None,
                 'commit_comment_url': 'http://comment-url',
                 'commit_comment_reply_url': 'http://comment-url#reply',
                 'comment_body': 'This is my comment body. *I like !*',
                 'comment_id': 2048,
                 'renderer_type': 'markdown',
                 'mention': True,
             },
+
             'cs_comment+status': {
                 'user': user,
                 'commit': AttributeDict(idx=123, raw_id='a' * 40, message='Commit message'),
                 'status_change': 'approved',
                 'status_change_type': 'approved',
 
                 'commit_target_repo_url': 'http://foo.example.com/#comment1',
                 'repo_name': 'test-repo',
                 'comment_type': 'note',
                 'comment_file': None,
                 'comment_line': None,
                 'commit_comment_url': 'http://comment-url',
                 'commit_comment_reply_url': 'http://comment-url#reply',
                 'comment_body': '''
 Hello **world**
 
 This is a multiline comment :)
 
 - list
 - list2
                 ''',
                 'comment_id': 2048,
                 'renderer_type': 'markdown',
                 'mention': True,
             },
+
             'cs_comment+file': {
                 'user': user,
                 'commit': AttributeDict(idx=123, raw_id='a' * 40, message='Commit message'),
                 'status_change': None,
                 'status_change_type': None,
 
                 'commit_target_repo_url': 'http://foo.example.com/#comment1',
                 'repo_name': 'test-repo',
 
                 'comment_type': 'note',
                 'comment_file': 'test-file.py',
                 'comment_line': 'n100',
 
                 'commit_comment_url': 'http://comment-url',
                 'commit_comment_reply_url': 'http://comment-url#reply',
                 'comment_body': 'This is my comment body. *I like !*',
                 'comment_id': 2048,
                 'renderer_type': 'markdown',
                 'mention': True,
             },
-            
+
             'pull_request': {
                 'user': user,
                 'pull_request': pr,
                 'pull_request_commits': [
                     ('472d1df03bf7206e278fcedc6ac92b46b01c4e21', '''\
+        my-account: moved email closer to profile as it's similar data just moved outside.                    
+                            '''),
+                    ('cbfa3061b6de2696c7161ed15ba5c6a0045f90a7', '''\
+        users: description edit fixes
+
+        - tests
+        - added metatags info                    
+                            '''),
+                ],
+
+                'pull_request_target_repo': target_repo,
+                'pull_request_target_repo_url': 'http://target-repo/url',
+
+                'pull_request_source_repo': source_repo,
+                'pull_request_source_repo_url': 'http://source-repo/url',
+
+                'pull_request_url': 'http://code.rhodecode.com/_pull-request/123',
+                'user_role': 'reviewer',
+            },
+
+            'pull_request+reviewer_role': {
+                'user': user,
+                'pull_request': pr,
+                'pull_request_commits': [
+                    ('472d1df03bf7206e278fcedc6ac92b46b01c4e21', '''\
 my-account: moved email closer to profile as it's similar data just moved outside.                    
                     '''),
                     ('cbfa3061b6de2696c7161ed15ba5c6a0045f90a7', '''\
 users: description edit fixes
 
 - tests
 - added metatags info                    
                     '''),
                 ],
 
                 'pull_request_target_repo': target_repo,
                 'pull_request_target_repo_url': 'http://target-repo/url',
 
                 'pull_request_source_repo': source_repo,
                 'pull_request_source_repo_url': 'http://source-repo/url',
 
                 'pull_request_url': 'http://code.rhodecode.com/_pull-request/123',
+                'user_role': 'reviewer',
+            },
+
+            'pull_request+observer_role': {
+                'user': user,
+                'pull_request': pr,
+                'pull_request_commits': [
+                    ('472d1df03bf7206e278fcedc6ac92b46b01c4e21', '''\
+        my-account: moved email closer to profile as it's similar data just moved outside.                    
+                            '''),
+                    ('cbfa3061b6de2696c7161ed15ba5c6a0045f90a7', '''\
+        users: description edit fixes
+
+        - tests
+        - added metatags info                    
+                            '''),
+                ],
+
+                'pull_request_target_repo': target_repo,
+                'pull_request_target_repo_url': 'http://target-repo/url',
+
+                'pull_request_source_repo': source_repo,
+                'pull_request_source_repo_url': 'http://source-repo/url',
+
+                'pull_request_url': 'http://code.rhodecode.com/_pull-request/123',
+                'user_role': 'observer'
             }
-
         }
 
         template_type = email_id.split('+')[0]
         (c.subject, c.email_body, c.email_body_plaintext) = EmailNotificationModel().render_email(
             template_type, **email_kwargs.get(email_id, {}))
 
         test_email = self.request.GET.get('email')
         if test_email:
             recipients = [test_email]
             run_task(tasks.send_email, recipients, c.subject,
                      c.email_body_plaintext, c.email_body)
 
         if self.request.matched_route.name == 'debug_style_email_plain_rendered':
             template = 'debug_style/email_plain_rendered.mako'
         else:
             template = 'debug_style/email.mako'
         return render_to_response(
             template, self._get_template_context(c),
             request=self.request)
 
     @view_config(
         route_name='debug_style_template', request_method='GET',
         renderer=None)
     def template(self):
         t_path = self.request.matchdict['t_path']
         c = self.load_default_context()
         c.active = os.path.splitext(t_path)[0]
         c.came_from = ''
+        # NOTE(marcink): extend the email types with variations based on data sets
         c.email_types = {
             'cs_comment+file': {},
             'cs_comment+status': {},
 
             'pull_request_comment+file': {},
             'pull_request_comment+status': {},
 
             'pull_request_update': {},
+
+            'pull_request+reviewer_role': {},
+            'pull_request+observer_role': {},
         }
         c.email_types.update(EmailNotificationModel.email_types)
 
         return render_to_response(
             'debug_style/' + t_path, self._get_template_context(c),
             request=self.request)
 

rhodecode/apps/repository/utils.py

@@ -1,87 +1,95 b''
 # -*- coding: utf-8 -*-
 
 # Copyright (C) 2016-2020 RhodeCode GmbH
 #
 # This program is free software: you can redistribute it and/or modify
 # it under the terms of the GNU Affero General Public License, version 3
 # (only), as published by the Free Software Foundation.
 #
 # 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 Affero General Public License
 # along with this program.  If not, see <http://www.gnu.org/licenses/>.
 #
 # This program is dual-licensed. If you wish to learn more about the
 # RhodeCode Enterprise Edition, including its added features, Support services,
 # and proprietary license terms, please see https://rhodecode.com/licenses/
 
 from rhodecode.lib import helpers as h
 from rhodecode.lib.utils2 import safe_int
 from rhodecode.model.pull_request import get_diff_info
-
-REVIEWER_API_VERSION = 'V3'
+from rhodecode.model.db import PullRequestReviewers
+# V3 - Reviewers, with default rules data
+# v4 - Added observers metadata
+REVIEWER_API_VERSION = 'V4'
 
 
-def reviewer_as_json(user, reasons=None, mandatory=False, rules=None, user_group=None):
+def reviewer_as_json(user, reasons=None, role=None, mandatory=False, rules=None, user_group=None):
     """
     Returns json struct of a reviewer for frontend
 
     :param user: the reviewer
     :param reasons: list of strings of why they are reviewers
     :param mandatory: bool, to set user as mandatory
     """
+    role = role or PullRequestReviewers.ROLE_REVIEWER
+    if role not in PullRequestReviewers.ROLES:
+        raise ValueError('role is not one of %s', PullRequestReviewers.ROLES)
 
     return {
         'user_id': user.user_id,
         'reasons': reasons or [],
         'rules': rules or [],
+        'role': role,
         'mandatory': mandatory,
         'user_group': user_group,
         'username': user.username,
         'first_name': user.first_name,
         'last_name': user.last_name,
         'user_link': h.link_to_user(user),
         'gravatar_link': h.gravatar_url(user.email, 14),
     }
 
 
-def get_default_reviewers_data(
-        current_user, source_repo, source_commit, target_repo, target_commit):
+def get_default_reviewers_data(current_user, source_repo, source_commit, target_repo, target_commit):
     """
     Return json for default reviewers of a repository
     """
 
     diff_info = get_diff_info(
         source_repo, source_commit.raw_id, target_repo, target_commit.raw_id)
 
     reasons = ['Default reviewer', 'Repository owner']
     json_reviewers = [reviewer_as_json(
-        user=target_repo.user, reasons=reasons, mandatory=False, rules=None)]
+        user=target_repo.user, reasons=reasons, mandatory=False, rules=None, role=None)]
 
     return {
         'api_ver': REVIEWER_API_VERSION,  # define version for later possible schema upgrade
         'diff_info': diff_info,
         'reviewers': json_reviewers,
         'rules': {},
         'rules_data': {},
     }
 
 
 def validate_default_reviewers(review_members, reviewer_rules):
     """
     Function to validate submitted reviewers against the saved rules
-
     """
     reviewers = []
     reviewer_by_id = {}
     for r in review_members:
         reviewer_user_id = safe_int(r['user_id'])
-        entry = (reviewer_user_id, r['reasons'], r['mandatory'], r['rules'])
+        entry = (reviewer_user_id, r['reasons'], r['mandatory'], r['role'], r['rules'])
 
         reviewer_by_id[reviewer_user_id] = entry
         reviewers.append(entry)
 
     return reviewers
+
+
+def validate_observers(observer_members):
+    return {}

rhodecode/apps/repository/views/repo_commits.py

@@ -1,781 +1,781 b''
 # -*- coding: utf-8 -*-
 
 # Copyright (C) 2010-2020 RhodeCode GmbH
 #
 # This program is free software: you can redistribute it and/or modify
 # it under the terms of the GNU Affero General Public License, version 3
 # (only), as published by the Free Software Foundation.
 #
 # 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 Affero General Public License
 # along with this program.  If not, see <http://www.gnu.org/licenses/>.
 #
 # This program is dual-licensed. If you wish to learn more about the
 # RhodeCode Enterprise Edition, including its added features, Support services,
 # and proprietary license terms, please see https://rhodecode.com/licenses/
 
 import logging
 import collections
 
 from pyramid.httpexceptions import (
     HTTPNotFound, HTTPBadRequest, HTTPFound, HTTPForbidden, HTTPConflict)
 from pyramid.view import view_config
 from pyramid.renderers import render
 from pyramid.response import Response
 
 from rhodecode.apps._base import RepoAppView
 from rhodecode.apps.file_store import utils as store_utils
 from rhodecode.apps.file_store.exceptions import FileNotAllowedException, FileOverSizeException
 
 from rhodecode.lib import diffs, codeblocks
 from rhodecode.lib.auth import (
     LoginRequired, HasRepoPermissionAnyDecorator, NotAnonymous, CSRFRequired)
 from rhodecode.lib.ext_json import json
 from rhodecode.lib.compat import OrderedDict
 from rhodecode.lib.diffs import (
     cache_diff, load_cached_diff, diff_cache_exist, get_diff_context,
     get_diff_whitespace_flag)
 from rhodecode.lib.exceptions import StatusChangeOnClosedPullRequestError, CommentVersionMismatch
 import rhodecode.lib.helpers as h
 from rhodecode.lib.utils2 import safe_unicode, str2bool, StrictAttributeDict
 from rhodecode.lib.vcs.backends.base import EmptyCommit
 from rhodecode.lib.vcs.exceptions import (
     RepositoryError, CommitDoesNotExistError)
 from rhodecode.model.db import ChangesetComment, ChangesetStatus, FileStore, \
     ChangesetCommentHistory
 from rhodecode.model.changeset_status import ChangesetStatusModel
 from rhodecode.model.comment import CommentsModel
 from rhodecode.model.meta import Session
 from rhodecode.model.settings import VcsSettingsModel
 
 log = logging.getLogger(__name__)
 
 
 def _update_with_GET(params, request):
     for k in ['diff1', 'diff2', 'diff']:
         params[k] += request.GET.getall(k)
 
 
 class RepoCommitsView(RepoAppView):
     def load_default_context(self):
         c = self._get_local_tmpl_context(include_app_defaults=True)
         c.rhodecode_repo = self.rhodecode_vcs_repo
 
         return c
 
     def _is_diff_cache_enabled(self, target_repo):
         caching_enabled = self._get_general_setting(
             target_repo, 'rhodecode_diff_cache')
         log.debug('Diff caching enabled: %s', caching_enabled)
         return caching_enabled
 
     def _commit(self, commit_id_range, method):
         _ = self.request.translate
         c = self.load_default_context()
         c.fulldiff = self.request.GET.get('fulldiff')
 
         # fetch global flags of ignore ws or context lines
         diff_context = get_diff_context(self.request)
         hide_whitespace_changes = get_diff_whitespace_flag(self.request)
 
         # diff_limit will cut off the whole diff if the limit is applied
         # otherwise it will just hide the big files from the front-end
         diff_limit = c.visual.cut_off_limit_diff
         file_limit = c.visual.cut_off_limit_file
 
         # get ranges of commit ids if preset
         commit_range = commit_id_range.split('...')[:2]
 
         try:
             pre_load = ['affected_files', 'author', 'branch', 'date',
                         'message', 'parents']
             if self.rhodecode_vcs_repo.alias == 'hg':
                 pre_load += ['hidden', 'obsolete', 'phase']
 
             if len(commit_range) == 2:
                 commits = self.rhodecode_vcs_repo.get_commits(
                     start_id=commit_range[0], end_id=commit_range[1],
                     pre_load=pre_load, translate_tags=False)
                 commits = list(commits)
             else:
                 commits = [self.rhodecode_vcs_repo.get_commit(
                     commit_id=commit_id_range, pre_load=pre_load)]
 
             c.commit_ranges = commits
             if not c.commit_ranges:
                 raise RepositoryError('The commit range returned an empty result')
         except CommitDoesNotExistError as e:
             msg = _('No such commit exists. Org exception: `{}`').format(e)
             h.flash(msg, category='error')
             raise HTTPNotFound()
         except Exception:
             log.exception("General failure")
             raise HTTPNotFound()
         single_commit = len(c.commit_ranges) == 1
 
         c.changes = OrderedDict()
         c.lines_added = 0
         c.lines_deleted = 0
 
         # auto collapse if we have more than limit
         collapse_limit = diffs.DiffProcessor._collapse_commits_over
         c.collapse_all_commits = len(c.commit_ranges) > collapse_limit
 
         c.commit_statuses = ChangesetStatus.STATUSES
         c.inline_comments = []
         c.files = []
 
         c.comments = []
         c.unresolved_comments = []
         c.resolved_comments = []
 
         # Single commit
         if single_commit:
             commit = c.commit_ranges[0]
             c.comments = CommentsModel().get_comments(
                 self.db_repo.repo_id,
                 revision=commit.raw_id)
 
             # comments from PR
             statuses = ChangesetStatusModel().get_statuses(
                 self.db_repo.repo_id, commit.raw_id,
                 with_revisions=True)
 
             prs = set()
             reviewers = list()
             reviewers_duplicates = set()  # to not have duplicates from multiple votes
             for c_status in statuses:
 
                 # extract associated pull-requests from votes
                 if c_status.pull_request:
                     prs.add(c_status.pull_request)
 
                 # extract reviewers
                 _user_id = c_status.author.user_id
                 if _user_id not in reviewers_duplicates:
                     reviewers.append(
                         StrictAttributeDict({
                             'user': c_status.author,
 
                             # fake attributed for commit, page that we don't have
                             # but we share the display with PR page
                             'mandatory': False,
                             'reasons': [],
                             'rule_user_group_data': lambda: None
                         })
                     )
                     reviewers_duplicates.add(_user_id)
 
             c.allowed_reviewers = reviewers
             # from associated statuses, check the pull requests, and
             # show comments from them
             for pr in prs:
                 c.comments.extend(pr.comments)
 
             c.unresolved_comments = CommentsModel()\
                 .get_commit_unresolved_todos(commit.raw_id)
             c.resolved_comments = CommentsModel()\
                 .get_commit_resolved_todos(commit.raw_id)
 
             c.inline_comments_flat = CommentsModel()\
                 .get_commit_inline_comments(commit.raw_id)
 
             review_statuses = ChangesetStatusModel().aggregate_votes_by_user(
                 statuses, reviewers)
 
             c.commit_review_status = ChangesetStatus.STATUS_NOT_REVIEWED
 
             c.commit_set_reviewers_data_json = collections.OrderedDict({'reviewers': []})
 
             for review_obj, member, reasons, mandatory, status in review_statuses:
                 member_reviewer = h.reviewer_as_json(
-                    member, reasons=reasons, mandatory=mandatory,
+                    member, reasons=reasons, mandatory=mandatory, role=None,
                     user_group=None
                 )
 
                 current_review_status = status[0][1].status if status else ChangesetStatus.STATUS_NOT_REVIEWED
                 member_reviewer['review_status'] = current_review_status
                 member_reviewer['review_status_label'] = h.commit_status_lbl(current_review_status)
                 member_reviewer['allowed_to_update'] = False
                 c.commit_set_reviewers_data_json['reviewers'].append(member_reviewer)
 
             c.commit_set_reviewers_data_json = json.dumps(c.commit_set_reviewers_data_json)
 
             # NOTE(marcink): this uses the same voting logic as in pull-requests
             c.commit_review_status = ChangesetStatusModel().calculate_status(review_statuses)
             c.commit_broadcast_channel = u'/repo${}$/commit/{}'.format(
                 c.repo_name,
                 commit.raw_id
             )
 
         diff = None
         # Iterate over ranges (default commit view is always one commit)
         for commit in c.commit_ranges:
             c.changes[commit.raw_id] = []
 
             commit2 = commit
             commit1 = commit.first_parent
 
             if method == 'show':
                 inline_comments = CommentsModel().get_inline_comments(
                     self.db_repo.repo_id, revision=commit.raw_id)
                 c.inline_cnt = len(CommentsModel().get_inline_comments_as_list(
                     inline_comments))
                 c.inline_comments = inline_comments
 
                 cache_path = self.rhodecode_vcs_repo.get_create_shadow_cache_pr_path(
                     self.db_repo)
                 cache_file_path = diff_cache_exist(
                     cache_path, 'diff', commit.raw_id,
                     hide_whitespace_changes, diff_context, c.fulldiff)
 
                 caching_enabled = self._is_diff_cache_enabled(self.db_repo)
                 force_recache = str2bool(self.request.GET.get('force_recache'))
 
                 cached_diff = None
                 if caching_enabled:
                     cached_diff = load_cached_diff(cache_file_path)
 
                 has_proper_diff_cache = cached_diff and cached_diff.get('diff')
                 if not force_recache and has_proper_diff_cache:
                     diffset = cached_diff['diff']
                 else:
                     vcs_diff = self.rhodecode_vcs_repo.get_diff(
                         commit1, commit2,
                         ignore_whitespace=hide_whitespace_changes,
                         context=diff_context)
 
                     diff_processor = diffs.DiffProcessor(
                         vcs_diff, format='newdiff', diff_limit=diff_limit,
                         file_limit=file_limit, show_full_diff=c.fulldiff)
 
                     _parsed = diff_processor.prepare()
 
                     diffset = codeblocks.DiffSet(
                         repo_name=self.db_repo_name,
                         source_node_getter=codeblocks.diffset_node_getter(commit1),
                         target_node_getter=codeblocks.diffset_node_getter(commit2))
 
                     diffset = self.path_filter.render_patchset_filtered(
                         diffset, _parsed, commit1.raw_id, commit2.raw_id)
 
                     # save cached diff
                     if caching_enabled:
                         cache_diff(cache_file_path, diffset, None)
 
                 c.limited_diff = diffset.limited_diff
                 c.changes[commit.raw_id] = diffset
             else:
                 # TODO(marcink): no cache usage here...
                 _diff = self.rhodecode_vcs_repo.get_diff(
                     commit1, commit2,
                     ignore_whitespace=hide_whitespace_changes, context=diff_context)
                 diff_processor = diffs.DiffProcessor(
                     _diff, format='newdiff', diff_limit=diff_limit,
                     file_limit=file_limit, show_full_diff=c.fulldiff)
                 # downloads/raw we only need RAW diff nothing else
                 diff = self.path_filter.get_raw_patch(diff_processor)
                 c.changes[commit.raw_id] = [None, None, None, None, diff, None, None]
 
         # sort comments by how they were generated
         c.comments = sorted(c.comments, key=lambda x: x.comment_id)
         c.at_version_num = None
 
         if len(c.commit_ranges) == 1:
             c.commit = c.commit_ranges[0]
             c.parent_tmpl = ''.join(
                 '# Parent  %s\n' % x.raw_id for x in c.commit.parents)
 
         if method == 'download':
             response = Response(diff)
             response.content_type = 'text/plain'
             response.content_disposition = (
                 'attachment; filename=%s.diff' % commit_id_range[:12])
             return response
         elif method == 'patch':
             c.diff = safe_unicode(diff)
             patch = render(
                 'rhodecode:templates/changeset/patch_changeset.mako',
                 self._get_template_context(c), self.request)
             response = Response(patch)
             response.content_type = 'text/plain'
             return response
         elif method == 'raw':
             response = Response(diff)
             response.content_type = 'text/plain'
             return response
         elif method == 'show':
             if len(c.commit_ranges) == 1:
                 html = render(
                     'rhodecode:templates/changeset/changeset.mako',
                     self._get_template_context(c), self.request)
                 return Response(html)
             else:
                 c.ancestor = None
                 c.target_repo = self.db_repo
                 html = render(
                     'rhodecode:templates/changeset/changeset_range.mako',
                     self._get_template_context(c), self.request)
                 return Response(html)
 
         raise HTTPBadRequest()
 
     @LoginRequired()
     @HasRepoPermissionAnyDecorator(
         'repository.read', 'repository.write', 'repository.admin')
     @view_config(
         route_name='repo_commit', request_method='GET',
         renderer=None)
     def repo_commit_show(self):
         commit_id = self.request.matchdict['commit_id']
         return self._commit(commit_id, method='show')
 
     @LoginRequired()
     @HasRepoPermissionAnyDecorator(
         'repository.read', 'repository.write', 'repository.admin')
     @view_config(
         route_name='repo_commit_raw', request_method='GET',
         renderer=None)
     @view_config(
         route_name='repo_commit_raw_deprecated', request_method='GET',
         renderer=None)
     def repo_commit_raw(self):
         commit_id = self.request.matchdict['commit_id']
         return self._commit(commit_id, method='raw')
 
     @LoginRequired()
     @HasRepoPermissionAnyDecorator(
         'repository.read', 'repository.write', 'repository.admin')
     @view_config(
         route_name='repo_commit_patch', request_method='GET',
         renderer=None)
     def repo_commit_patch(self):
         commit_id = self.request.matchdict['commit_id']
         return self._commit(commit_id, method='patch')
 
     @LoginRequired()
     @HasRepoPermissionAnyDecorator(
         'repository.read', 'repository.write', 'repository.admin')
     @view_config(
         route_name='repo_commit_download', request_method='GET',
         renderer=None)
     def repo_commit_download(self):
         commit_id = self.request.matchdict['commit_id']
         return self._commit(commit_id, method='download')
 
     @LoginRequired()
     @NotAnonymous()
     @HasRepoPermissionAnyDecorator(
         'repository.read', 'repository.write', 'repository.admin')
     @CSRFRequired()
     @view_config(
         route_name='repo_commit_comment_create', request_method='POST',
         renderer='json_ext')
     def repo_commit_comment_create(self):
         _ = self.request.translate
         commit_id = self.request.matchdict['commit_id']
 
         c = self.load_default_context()
         status = self.request.POST.get('changeset_status', None)
         text = self.request.POST.get('text')
         comment_type = self.request.POST.get('comment_type')
         resolves_comment_id = self.request.POST.get('resolves_comment_id', None)
 
         if status:
             text = text or (_('Status change %(transition_icon)s %(status)s')
                             % {'transition_icon': '>',
                                'status': ChangesetStatus.get_status_lbl(status)})
 
         multi_commit_ids = []
         for _commit_id in self.request.POST.get('commit_ids', '').split(','):
             if _commit_id not in ['', None, EmptyCommit.raw_id]:
                 if _commit_id not in multi_commit_ids:
                     multi_commit_ids.append(_commit_id)
 
         commit_ids = multi_commit_ids or [commit_id]
 
         comment = None
         for current_id in filter(None, commit_ids):
             comment = CommentsModel().create(
                 text=text,
                 repo=self.db_repo.repo_id,
                 user=self._rhodecode_db_user.user_id,
                 commit_id=current_id,
                 f_path=self.request.POST.get('f_path'),
                 line_no=self.request.POST.get('line'),
                 status_change=(ChangesetStatus.get_status_lbl(status)
                                if status else None),
                 status_change_type=status,
                 comment_type=comment_type,
                 resolves_comment_id=resolves_comment_id,
                 auth_user=self._rhodecode_user
             )
 
             # get status if set !
             if status:
                 # if latest status was from pull request and it's closed
                 # disallow changing status !
                 # dont_allow_on_closed_pull_request = True !
 
                 try:
                     ChangesetStatusModel().set_status(
                         self.db_repo.repo_id,
                         status,
                         self._rhodecode_db_user.user_id,
                         comment,
                         revision=current_id,
                         dont_allow_on_closed_pull_request=True
                     )
                 except StatusChangeOnClosedPullRequestError:
                     msg = _('Changing the status of a commit associated with '
                             'a closed pull request is not allowed')
                     log.exception(msg)
                     h.flash(msg, category='warning')
                     raise HTTPFound(h.route_path(
                         'repo_commit', repo_name=self.db_repo_name,
                         commit_id=current_id))
 
             commit = self.db_repo.get_commit(current_id)
             CommentsModel().trigger_commit_comment_hook(
                 self.db_repo, self._rhodecode_user, 'create',
                 data={'comment': comment, 'commit': commit})
 
         # finalize, commit and redirect
         Session().commit()
 
         data = {
             'target_id': h.safeid(h.safe_unicode(
                 self.request.POST.get('f_path'))),
         }
         if comment:
             c.co = comment
             c.at_version_num = 0
             rendered_comment = render(
                 'rhodecode:templates/changeset/changeset_comment_block.mako',
                 self._get_template_context(c), self.request)
 
             data.update(comment.get_dict())
             data.update({'rendered_text': rendered_comment})
 
         return data
 
     @LoginRequired()
     @NotAnonymous()
     @HasRepoPermissionAnyDecorator(
         'repository.read', 'repository.write', 'repository.admin')
     @CSRFRequired()
     @view_config(
         route_name='repo_commit_comment_preview', request_method='POST',
         renderer='string', xhr=True)
     def repo_commit_comment_preview(self):
         # Technically a CSRF token is not needed as no state changes with this
         # call. However, as this is a POST is better to have it, so automated
         # tools don't flag it as potential CSRF.
         # Post is required because the payload could be bigger than the maximum
         # allowed by GET.
 
         text = self.request.POST.get('text')
         renderer = self.request.POST.get('renderer') or 'rst'
         if text:
             return h.render(text, renderer=renderer, mentions=True,
                             repo_name=self.db_repo_name)
         return ''
 
     @LoginRequired()
     @HasRepoPermissionAnyDecorator(
         'repository.read', 'repository.write', 'repository.admin')
     @CSRFRequired()
     @view_config(
         route_name='repo_commit_comment_history_view', request_method='POST',
         renderer='string', xhr=True)
     def repo_commit_comment_history_view(self):
         c = self.load_default_context()
 
         comment_history_id = self.request.matchdict['comment_history_id']
         comment_history = ChangesetCommentHistory.get_or_404(comment_history_id)
         is_repo_comment = comment_history.comment.repo.repo_id == self.db_repo.repo_id
 
         if is_repo_comment:
             c.comment_history = comment_history
 
             rendered_comment = render(
                 'rhodecode:templates/changeset/comment_history.mako',
                 self._get_template_context(c)
                 , self.request)
             return rendered_comment
         else:
             log.warning('No permissions for user %s to show comment_history_id: %s',
                         self._rhodecode_db_user, comment_history_id)
             raise HTTPNotFound()
 
     @LoginRequired()
     @NotAnonymous()
     @HasRepoPermissionAnyDecorator(
         'repository.read', 'repository.write', 'repository.admin')
     @CSRFRequired()
     @view_config(
         route_name='repo_commit_comment_attachment_upload', request_method='POST',
         renderer='json_ext', xhr=True)
     def repo_commit_comment_attachment_upload(self):
         c = self.load_default_context()
         upload_key = 'attachment'
 
         file_obj = self.request.POST.get(upload_key)
 
         if file_obj is None:
             self.request.response.status = 400
             return {'store_fid': None,
                     'access_path': None,
                     'error': '{} data field is missing'.format(upload_key)}
 
         if not hasattr(file_obj, 'filename'):
             self.request.response.status = 400
             return {'store_fid': None,
                     'access_path': None,
                     'error': 'filename cannot be read from the data field'}
 
         filename = file_obj.filename
         file_display_name = filename
 
         metadata = {
             'user_uploaded': {'username': self._rhodecode_user.username,
                               'user_id': self._rhodecode_user.user_id,
                               'ip': self._rhodecode_user.ip_addr}}
 
         # TODO(marcink): allow .ini configuration for allowed_extensions, and file-size
         allowed_extensions = [
             'gif', '.jpeg', '.jpg', '.png', '.docx', '.gz', '.log', '.pdf',
             '.pptx', '.txt', '.xlsx', '.zip']
         max_file_size = 10 * 1024 * 1024  # 10MB, also validated via dropzone.js
 
         try:
             storage = store_utils.get_file_storage(self.request.registry.settings)
             store_uid, metadata = storage.save_file(
                 file_obj.file, filename, extra_metadata=metadata,
                 extensions=allowed_extensions, max_filesize=max_file_size)
         except FileNotAllowedException:
             self.request.response.status = 400
             permitted_extensions = ', '.join(allowed_extensions)
             error_msg = 'File `{}` is not allowed. ' \
                         'Only following extensions are permitted: {}'.format(
                             filename, permitted_extensions)
             return {'store_fid': None,
                     'access_path': None,
                     'error': error_msg}
         except FileOverSizeException:
             self.request.response.status = 400
             limit_mb = h.format_byte_size_binary(max_file_size)
             return {'store_fid': None,
                     'access_path': None,
                     'error': 'File {} is exceeding allowed limit of {}.'.format(
                         filename, limit_mb)}
 
         try:
             entry = FileStore.create(
                 file_uid=store_uid, filename=metadata["filename"],
                 file_hash=metadata["sha256"], file_size=metadata["size"],
                 file_display_name=file_display_name,
                 file_description=u'comment attachment `{}`'.format(safe_unicode(filename)),
                 hidden=True, check_acl=True, user_id=self._rhodecode_user.user_id,
                 scope_repo_id=self.db_repo.repo_id
             )
             Session().add(entry)
             Session().commit()
             log.debug('Stored upload in DB as %s', entry)
         except Exception:
             log.exception('Failed to store file %s', filename)
             self.request.response.status = 400
             return {'store_fid': None,
                     'access_path': None,
                     'error': 'File {} failed to store in DB.'.format(filename)}
 
         Session().commit()
 
         return {
             'store_fid': store_uid,
             'access_path': h.route_path(
                 'download_file', fid=store_uid),
             'fqn_access_path': h.route_url(
                 'download_file', fid=store_uid),
             'repo_access_path': h.route_path(
                 'repo_artifacts_get', repo_name=self.db_repo_name, uid=store_uid),
             'repo_fqn_access_path': h.route_url(
                 'repo_artifacts_get', repo_name=self.db_repo_name, uid=store_uid),
         }
 
     @LoginRequired()
     @NotAnonymous()
     @HasRepoPermissionAnyDecorator(
         'repository.read', 'repository.write', 'repository.admin')
     @CSRFRequired()
     @view_config(
         route_name='repo_commit_comment_delete', request_method='POST',
         renderer='json_ext')
     def repo_commit_comment_delete(self):
         commit_id = self.request.matchdict['commit_id']
         comment_id = self.request.matchdict['comment_id']
 
         comment = ChangesetComment.get_or_404(comment_id)
         if not comment:
             log.debug('Comment with id:%s not found, skipping', comment_id)
             # comment already deleted in another call probably
             return True
 
         if comment.immutable:
             # don't allow deleting comments that are immutable
             raise HTTPForbidden()
 
         is_repo_admin = h.HasRepoPermissionAny('repository.admin')(self.db_repo_name)
         super_admin = h.HasPermissionAny('hg.admin')()
         comment_owner = (comment.author.user_id == self._rhodecode_db_user.user_id)
         is_repo_comment = comment.repo.repo_id == self.db_repo.repo_id
         comment_repo_admin = is_repo_admin and is_repo_comment
 
         if super_admin or comment_owner or comment_repo_admin:
             CommentsModel().delete(comment=comment, auth_user=self._rhodecode_user)
             Session().commit()
             return True
         else:
             log.warning('No permissions for user %s to delete comment_id: %s',
                         self._rhodecode_db_user, comment_id)
             raise HTTPNotFound()
 
     @LoginRequired()
     @NotAnonymous()
     @HasRepoPermissionAnyDecorator(
         'repository.read', 'repository.write', 'repository.admin')
     @CSRFRequired()
     @view_config(
         route_name='repo_commit_comment_edit', request_method='POST',
         renderer='json_ext')
     def repo_commit_comment_edit(self):
         self.load_default_context()
 
         comment_id = self.request.matchdict['comment_id']
         comment = ChangesetComment.get_or_404(comment_id)
 
         if comment.immutable:
             # don't allow deleting comments that are immutable
             raise HTTPForbidden()
 
         is_repo_admin = h.HasRepoPermissionAny('repository.admin')(self.db_repo_name)
         super_admin = h.HasPermissionAny('hg.admin')()
         comment_owner = (comment.author.user_id == self._rhodecode_db_user.user_id)
         is_repo_comment = comment.repo.repo_id == self.db_repo.repo_id
         comment_repo_admin = is_repo_admin and is_repo_comment
 
         if super_admin or comment_owner or comment_repo_admin:
             text = self.request.POST.get('text')
             version = self.request.POST.get('version')
             if text == comment.text:
                 log.warning(
                     'Comment(repo): '
                     'Trying to create new version '
                     'with the same comment body {}'.format(
                         comment_id,
                     )
                 )
                 raise HTTPNotFound()
 
             if version.isdigit():
                 version = int(version)
             else:
                 log.warning(
                     'Comment(repo): Wrong version type {} {} '
                     'for comment {}'.format(
                         version,
                         type(version),
                         comment_id,
                     )
                 )
                 raise HTTPNotFound()
 
             try:
                 comment_history = CommentsModel().edit(
                     comment_id=comment_id,
                     text=text,
                     auth_user=self._rhodecode_user,
                     version=version,
                 )
             except CommentVersionMismatch:
                 raise HTTPConflict()
 
             if not comment_history:
                 raise HTTPNotFound()
 
             commit_id = self.request.matchdict['commit_id']
             commit = self.db_repo.get_commit(commit_id)
             CommentsModel().trigger_commit_comment_hook(
                 self.db_repo, self._rhodecode_user, 'edit',
                 data={'comment': comment, 'commit': commit})
 
             Session().commit()
             return {
                 'comment_history_id': comment_history.comment_history_id,
                 'comment_id': comment.comment_id,
                 'comment_version': comment_history.version,
                 'comment_author_username': comment_history.author.username,
                 'comment_author_gravatar': h.gravatar_url(comment_history.author.email, 16),
                 'comment_created_on': h.age_component(comment_history.created_on,
                                                       time_is_local=True),
             }
         else:
             log.warning('No permissions for user %s to edit comment_id: %s',
                         self._rhodecode_db_user, comment_id)
             raise HTTPNotFound()
 
     @LoginRequired()
     @HasRepoPermissionAnyDecorator(
         'repository.read', 'repository.write', 'repository.admin')
     @view_config(
         route_name='repo_commit_data', request_method='GET',
         renderer='json_ext', xhr=True)
     def repo_commit_data(self):
         commit_id = self.request.matchdict['commit_id']
         self.load_default_context()
 
         try:
             return self.rhodecode_vcs_repo.get_commit(commit_id=commit_id)
         except CommitDoesNotExistError as e:
             return EmptyCommit(message=str(e))
 
     @LoginRequired()
     @HasRepoPermissionAnyDecorator(
         'repository.read', 'repository.write', 'repository.admin')
     @view_config(
         route_name='repo_commit_children', request_method='GET',
         renderer='json_ext', xhr=True)
     def repo_commit_children(self):
         commit_id = self.request.matchdict['commit_id']
         self.load_default_context()
 
         try:
             commit = self.rhodecode_vcs_repo.get_commit(commit_id=commit_id)
             children = commit.children
         except CommitDoesNotExistError:
             children = []
 
         result = {"results": children}
         return result
 
     @LoginRequired()
     @HasRepoPermissionAnyDecorator(
         'repository.read', 'repository.write', 'repository.admin')
     @view_config(
         route_name='repo_commit_parents', request_method='GET',
         renderer='json_ext')
     def repo_commit_parents(self):
         commit_id = self.request.matchdict['commit_id']
         self.load_default_context()
 
         try:
             commit = self.rhodecode_vcs_repo.get_commit(commit_id=commit_id)
             parents = commit.parents
         except CommitDoesNotExistError:
             parents = []
         result = {"results": parents}
         return result

rhodecode/apps/repository/views/repo_pull_requests.py

@@ -1,1757 +1,1794 b''
 # -*- coding: utf-8 -*-
 
 # Copyright (C) 2011-2020 RhodeCode GmbH
 #
 # This program is free software: you can redistribute it and/or modify
 # it under the terms of the GNU Affero General Public License, version 3
 # (only), as published by the Free Software Foundation.
 #
 # 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 Affero General Public License
 # along with this program.  If not, see <http://www.gnu.org/licenses/>.
 #
 # This program is dual-licensed. If you wish to learn more about the
 # RhodeCode Enterprise Edition, including its added features, Support services,
 # and proprietary license terms, please see https://rhodecode.com/licenses/
 
 import logging
 import collections
 
 import formencode
 import formencode.htmlfill
 import peppercorn
 from pyramid.httpexceptions import (
     HTTPFound, HTTPNotFound, HTTPForbidden, HTTPBadRequest, HTTPConflict)
 from pyramid.view import view_config
 from pyramid.renderers import render
 
 from rhodecode.apps._base import RepoAppView, DataGridAppView
 
 from rhodecode.lib import helpers as h, diffs, codeblocks, channelstream
 from rhodecode.lib.base import vcs_operation_context
 from rhodecode.lib.diffs import load_cached_diff, cache_diff, diff_cache_exist
 from rhodecode.lib.exceptions import CommentVersionMismatch
 from rhodecode.lib.ext_json import json
 from rhodecode.lib.auth import (
     LoginRequired, HasRepoPermissionAny, HasRepoPermissionAnyDecorator,
     NotAnonymous, CSRFRequired)
-from rhodecode.lib.utils2 import str2bool, safe_str, safe_unicode, safe_int
+from rhodecode.lib.utils2 import str2bool, safe_str, safe_unicode, safe_int, aslist
 from rhodecode.lib.vcs.backends.base import EmptyCommit, UpdateFailureReason
 from rhodecode.lib.vcs.exceptions import (
     CommitDoesNotExistError, RepositoryRequirementError, EmptyRepositoryError)
 from rhodecode.model.changeset_status import ChangesetStatusModel
 from rhodecode.model.comment import CommentsModel
 from rhodecode.model.db import (
-    func, or_, PullRequest, ChangesetComment, ChangesetStatus, Repository)
+    func, or_, PullRequest, ChangesetComment, ChangesetStatus, Repository,
+    PullRequestReviewers)
 from rhodecode.model.forms import PullRequestForm
 from rhodecode.model.meta import Session
 from rhodecode.model.pull_request import PullRequestModel, MergeCheck
 from rhodecode.model.scm import ScmModel
 
 log = logging.getLogger(__name__)
 
 
 class RepoPullRequestsView(RepoAppView, DataGridAppView):
 
     def load_default_context(self):
         c = self._get_local_tmpl_context(include_app_defaults=True)
         c.REVIEW_STATUS_APPROVED = ChangesetStatus.STATUS_APPROVED
         c.REVIEW_STATUS_REJECTED = ChangesetStatus.STATUS_REJECTED
         # backward compat., we use for OLD PRs a plain renderer
         c.renderer = 'plain'
         return c
 
     def _get_pull_requests_list(
             self, repo_name, source, filter_type, opened_by, statuses):
 
         draw, start, limit = self._extract_chunk(self.request)
         search_q, order_by, order_dir = self._extract_ordering(self.request)
         _render = self.request.get_partial_renderer(
             'rhodecode:templates/data_table/_dt_elements.mako')
 
         # pagination
 
         if filter_type == 'awaiting_review':
             pull_requests = PullRequestModel().get_awaiting_review(
                 repo_name, search_q=search_q, source=source, opened_by=opened_by,
                 statuses=statuses, offset=start, length=limit,
                 order_by=order_by, order_dir=order_dir)
             pull_requests_total_count = PullRequestModel().count_awaiting_review(
                 repo_name, search_q=search_q, source=source, statuses=statuses,
                 opened_by=opened_by)
         elif filter_type == 'awaiting_my_review':
             pull_requests = PullRequestModel().get_awaiting_my_review(
                 repo_name, search_q=search_q, source=source, opened_by=opened_by,
                 user_id=self._rhodecode_user.user_id, statuses=statuses,
                 offset=start, length=limit, order_by=order_by,
                 order_dir=order_dir)
             pull_requests_total_count = PullRequestModel().count_awaiting_my_review(
                 repo_name, search_q=search_q, source=source, user_id=self._rhodecode_user.user_id,
                 statuses=statuses, opened_by=opened_by)
         else:
             pull_requests = PullRequestModel().get_all(
                 repo_name, search_q=search_q, source=source, opened_by=opened_by,
                 statuses=statuses, offset=start, length=limit,
                 order_by=order_by, order_dir=order_dir)
             pull_requests_total_count = PullRequestModel().count_all(
                 repo_name, search_q=search_q, source=source, statuses=statuses,
                 opened_by=opened_by)
 
         data = []
         comments_model = CommentsModel()
         for pr in pull_requests:
             comments = comments_model.get_all_comments(
                 self.db_repo.repo_id, pull_request=pr)
 
             data.append({
                 'name': _render('pullrequest_name',
                                 pr.pull_request_id, pr.pull_request_state,
                                 pr.work_in_progress, pr.target_repo.repo_name),
                 'name_raw': pr.pull_request_id,
                 'status': _render('pullrequest_status',
                                   pr.calculated_review_status()),
                 'title': _render('pullrequest_title', pr.title, pr.description),
                 'description': h.escape(pr.description),
                 'updated_on': _render('pullrequest_updated_on',
                                       h.datetime_to_time(pr.updated_on)),
                 'updated_on_raw': h.datetime_to_time(pr.updated_on),
                 'created_on': _render('pullrequest_updated_on',
                                       h.datetime_to_time(pr.created_on)),
                 'created_on_raw': h.datetime_to_time(pr.created_on),
                 'state': pr.pull_request_state,
                 'author': _render('pullrequest_author',
                                   pr.author.full_contact, ),
                 'author_raw': pr.author.full_name,
                 'comments': _render('pullrequest_comments', len(comments)),
                 'comments_raw': len(comments),
                 'closed': pr.is_closed(),
             })
 
         data = ({
             'draw': draw,
             'data': data,
             'recordsTotal': pull_requests_total_count,
             'recordsFiltered': pull_requests_total_count,
         })
         return data
 
     @LoginRequired()
     @HasRepoPermissionAnyDecorator(
         'repository.read', 'repository.write', 'repository.admin')
     @view_config(
         route_name='pullrequest_show_all', request_method='GET',
         renderer='rhodecode:templates/pullrequests/pullrequests.mako')
     def pull_request_list(self):
         c = self.load_default_context()
 
         req_get = self.request.GET
         c.source = str2bool(req_get.get('source'))
         c.closed = str2bool(req_get.get('closed'))
         c.my = str2bool(req_get.get('my'))
         c.awaiting_review = str2bool(req_get.get('awaiting_review'))
         c.awaiting_my_review = str2bool(req_get.get('awaiting_my_review'))
 
         c.active = 'open'
         if c.my:
             c.active = 'my'
         if c.closed:
             c.active = 'closed'
         if c.awaiting_review and not c.source:
             c.active = 'awaiting'
         if c.source and not c.awaiting_review:
             c.active = 'source'
         if c.awaiting_my_review:
             c.active = 'awaiting_my'
 
         return self._get_template_context(c)
 
     @LoginRequired()
     @HasRepoPermissionAnyDecorator(
         'repository.read', 'repository.write', 'repository.admin')
     @view_config(
         route_name='pullrequest_show_all_data', request_method='GET',
         renderer='json_ext', xhr=True)
     def pull_request_list_data(self):
         self.load_default_context()
 
         # additional filters
         req_get = self.request.GET
         source = str2bool(req_get.get('source'))
         closed = str2bool(req_get.get('closed'))
         my = str2bool(req_get.get('my'))
         awaiting_review = str2bool(req_get.get('awaiting_review'))
         awaiting_my_review = str2bool(req_get.get('awaiting_my_review'))
 
         filter_type = 'awaiting_review' if awaiting_review \
             else 'awaiting_my_review' if awaiting_my_review \
             else None
 
         opened_by = None
         if my:
             opened_by = [self._rhodecode_user.user_id]
 
         statuses = [PullRequest.STATUS_NEW, PullRequest.STATUS_OPEN]
         if closed:
             statuses = [PullRequest.STATUS_CLOSED]
 
         data = self._get_pull_requests_list(
             repo_name=self.db_repo_name, source=source,
             filter_type=filter_type, opened_by=opened_by, statuses=statuses)
 
         return data
 
     def _is_diff_cache_enabled(self, target_repo):
         caching_enabled = self._get_general_setting(
             target_repo, 'rhodecode_diff_cache')
         log.debug('Diff caching enabled: %s', caching_enabled)
         return caching_enabled
 
     def _get_diffset(self, source_repo_name, source_repo,
                      ancestor_commit,
                      source_ref_id, target_ref_id,
                      target_commit, source_commit, diff_limit, file_limit,
                      fulldiff, hide_whitespace_changes, diff_context, use_ancestor=True):
 
         if use_ancestor:
             # we might want to not use it for versions
             target_ref_id = ancestor_commit.raw_id
 
         vcs_diff = PullRequestModel().get_diff(
             source_repo, source_ref_id, target_ref_id,
             hide_whitespace_changes, diff_context)
 
         diff_processor = diffs.DiffProcessor(
             vcs_diff, format='newdiff', diff_limit=diff_limit,
             file_limit=file_limit, show_full_diff=fulldiff)
 
         _parsed = diff_processor.prepare()
 
         diffset = codeblocks.DiffSet(
             repo_name=self.db_repo_name,
             source_repo_name=source_repo_name,
             source_node_getter=codeblocks.diffset_node_getter(target_commit),
             target_node_getter=codeblocks.diffset_node_getter(source_commit),
         )
         diffset = self.path_filter.render_patchset_filtered(
             diffset, _parsed, target_commit.raw_id, source_commit.raw_id)
 
         return diffset
 
     def _get_range_diffset(self, source_scm, source_repo,
                            commit1, commit2, diff_limit, file_limit,
                            fulldiff, hide_whitespace_changes, diff_context):
         vcs_diff = source_scm.get_diff(
             commit1, commit2,
             ignore_whitespace=hide_whitespace_changes,
             context=diff_context)
 
         diff_processor = diffs.DiffProcessor(
             vcs_diff, format='newdiff', diff_limit=diff_limit,
             file_limit=file_limit, show_full_diff=fulldiff)
 
         _parsed = diff_processor.prepare()
 
         diffset = codeblocks.DiffSet(
             repo_name=source_repo.repo_name,
             source_node_getter=codeblocks.diffset_node_getter(commit1),
             target_node_getter=codeblocks.diffset_node_getter(commit2))
 
         diffset = self.path_filter.render_patchset_filtered(
             diffset, _parsed, commit1.raw_id, commit2.raw_id)
 
         return diffset
 
     def register_comments_vars(self, c, pull_request, versions):
         comments_model = CommentsModel()
 
         # GENERAL COMMENTS with versions #
         q = comments_model._all_general_comments_of_pull_request(pull_request)
         q = q.order_by(ChangesetComment.comment_id.asc())
         general_comments = q
 
         # pick comments we want to render at current version
         c.comment_versions = comments_model.aggregate_comments(
             general_comments, versions, c.at_version_num)
 
         # INLINE COMMENTS with versions  #
         q = comments_model._all_inline_comments_of_pull_request(pull_request)
         q = q.order_by(ChangesetComment.comment_id.asc())
         inline_comments = q
 
         c.inline_versions = comments_model.aggregate_comments(
             inline_comments, versions, c.at_version_num, inline=True)
 
         # Comments inline+general
         if c.at_version:
             c.inline_comments_flat = c.inline_versions[c.at_version_num]['display']
             c.comments = c.comment_versions[c.at_version_num]['display']
         else:
             c.inline_comments_flat = c.inline_versions[c.at_version_num]['until']
             c.comments = c.comment_versions[c.at_version_num]['until']
 
         return general_comments, inline_comments
 
     @LoginRequired()
     @HasRepoPermissionAnyDecorator(
         'repository.read', 'repository.write', 'repository.admin')
     @view_config(
         route_name='pullrequest_show', request_method='GET',
         renderer='rhodecode:templates/pullrequests/pullrequest_show.mako')
     def pull_request_show(self):
         _ = self.request.translate
         c = self.load_default_context()
 
         pull_request = PullRequest.get_or_404(
             self.request.matchdict['pull_request_id'])
         pull_request_id = pull_request.pull_request_id
 
         c.state_progressing = pull_request.is_state_changing()
         c.pr_broadcast_channel = '/repo${}$/pr/{}'.format(
             pull_request.target_repo.repo_name, pull_request.pull_request_id)
 
         _new_state = {
             'created': PullRequest.STATE_CREATED,
         }.get(self.request.GET.get('force_state'))
 
         if c.is_super_admin and _new_state:
             with pull_request.set_state(PullRequest.STATE_UPDATING, final_state=_new_state):
                 h.flash(
                     _('Pull Request state was force changed to `{}`').format(_new_state),
                     category='success')
                 Session().commit()
 
             raise HTTPFound(h.route_path(
                 'pullrequest_show', repo_name=self.db_repo_name,
                 pull_request_id=pull_request_id))
 
         version = self.request.GET.get('version')
         from_version = self.request.GET.get('from_version') or version
         merge_checks = self.request.GET.get('merge_checks')
         c.fulldiff = str2bool(self.request.GET.get('fulldiff'))
         force_refresh = str2bool(self.request.GET.get('force_refresh'))
         c.range_diff_on = self.request.GET.get('range-diff') == "1"
 
         # fetch global flags of ignore ws or context lines
         diff_context = diffs.get_diff_context(self.request)
         hide_whitespace_changes = diffs.get_diff_whitespace_flag(self.request)
 
         (pull_request_latest,
          pull_request_at_ver,
          pull_request_display_obj,
          at_version) = PullRequestModel().get_pr_version(
             pull_request_id, version=version)
 
         pr_closed = pull_request_latest.is_closed()
 
         if pr_closed and (version or from_version):
             # not allow to browse versions for closed PR
             raise HTTPFound(h.route_path(
                 'pullrequest_show', repo_name=self.db_repo_name,
                 pull_request_id=pull_request_id))
 
         versions = pull_request_display_obj.versions()
         # used to store per-commit range diffs
         c.changes = collections.OrderedDict()
 
         c.at_version = at_version
         c.at_version_num = (at_version
                             if at_version and at_version != PullRequest.LATEST_VER
                             else None)
 
         c.at_version_index = ChangesetComment.get_index_from_version(
             c.at_version_num, versions)
 
         (prev_pull_request_latest,
          prev_pull_request_at_ver,
          prev_pull_request_display_obj,
          prev_at_version) = PullRequestModel().get_pr_version(
             pull_request_id, version=from_version)
 
         c.from_version = prev_at_version
         c.from_version_num = (prev_at_version
                               if prev_at_version and prev_at_version != PullRequest.LATEST_VER
                               else None)
         c.from_version_index = ChangesetComment.get_index_from_version(
             c.from_version_num, versions)
 
         # define if we're in COMPARE mode or VIEW at version mode
         compare = at_version != prev_at_version
 
         # pull_requests repo_name we opened it against
         # ie. target_repo must match
         if self.db_repo_name != pull_request_at_ver.target_repo.repo_name:
             log.warning('Mismatch between the current repo: %s, and target %s',
                         self.db_repo_name, pull_request_at_ver.target_repo.repo_name)
             raise HTTPNotFound()
 
         c.shadow_clone_url = PullRequestModel().get_shadow_clone_url(pull_request_at_ver)
 
         c.pull_request = pull_request_display_obj
         c.renderer = pull_request_at_ver.description_renderer or c.renderer
         c.pull_request_latest = pull_request_latest
 
         # inject latest version
         latest_ver = PullRequest.get_pr_display_object(pull_request_latest, pull_request_latest)
         c.versions = versions + [latest_ver]
 
         if compare or (at_version and not at_version == PullRequest.LATEST_VER):
             c.allowed_to_change_status = False
             c.allowed_to_update = False
             c.allowed_to_merge = False
             c.allowed_to_delete = False
             c.allowed_to_comment = False
             c.allowed_to_close = False
         else:
             can_change_status = PullRequestModel().check_user_change_status(
                 pull_request_at_ver, self._rhodecode_user)
             c.allowed_to_change_status = can_change_status and not pr_closed
 
             c.allowed_to_update = PullRequestModel().check_user_update(
                 pull_request_latest, self._rhodecode_user) and not pr_closed
             c.allowed_to_merge = PullRequestModel().check_user_merge(
                 pull_request_latest, self._rhodecode_user) and not pr_closed
             c.allowed_to_delete = PullRequestModel().check_user_delete(
                 pull_request_latest, self._rhodecode_user) and not pr_closed
             c.allowed_to_comment = not pr_closed
             c.allowed_to_close = c.allowed_to_merge and not pr_closed
 
         c.forbid_adding_reviewers = False
         c.forbid_author_to_review = False
         c.forbid_commit_author_to_review = False
 
         if pull_request_latest.reviewer_data and \
                         'rules' in pull_request_latest.reviewer_data:
             rules = pull_request_latest.reviewer_data['rules'] or {}
             try:
                 c.forbid_adding_reviewers = rules.get('forbid_adding_reviewers')
                 c.forbid_author_to_review = rules.get('forbid_author_to_review')
                 c.forbid_commit_author_to_review = rules.get('forbid_commit_author_to_review')
             except Exception:
                 pass
 
         # check merge capabilities
         _merge_check = MergeCheck.validate(
             pull_request_latest, auth_user=self._rhodecode_user,
             translator=self.request.translate,
             force_shadow_repo_refresh=force_refresh)
 
         c.pr_merge_errors = _merge_check.error_details
         c.pr_merge_possible = not _merge_check.failed
         c.pr_merge_message = _merge_check.merge_msg
         c.pr_merge_source_commit = _merge_check.source_commit
         c.pr_merge_target_commit = _merge_check.target_commit
 
         c.pr_merge_info = MergeCheck.get_merge_conditions(
             pull_request_latest, translator=self.request.translate)
 
         c.pull_request_review_status = _merge_check.review_status
         if merge_checks:
             self.request.override_renderer = \
                 'rhodecode:templates/pullrequests/pullrequest_merge_checks.mako'
             return self._get_template_context(c)
 
         c.allowed_reviewers = [obj.user_id for obj in pull_request.reviewers if obj.user]
+        c.reviewers_count = pull_request.reviewers_count
+        c.observers_count = pull_request.observers_count
 
         # reviewers and statuses
         c.pull_request_default_reviewers_data_json = json.dumps(pull_request.reviewer_data)
         c.pull_request_set_reviewers_data_json = collections.OrderedDict({'reviewers': []})
+        c.pull_request_set_observers_data_json = collections.OrderedDict({'observers': []})
 
         for review_obj, member, reasons, mandatory, status in pull_request_at_ver.reviewers_statuses():
             member_reviewer = h.reviewer_as_json(
                 member, reasons=reasons, mandatory=mandatory,
+                role=review_obj.role,
                 user_group=review_obj.rule_user_group_data()
             )
 
             current_review_status = status[0][1].status if status else ChangesetStatus.STATUS_NOT_REVIEWED
             member_reviewer['review_status'] = current_review_status
             member_reviewer['review_status_label'] = h.commit_status_lbl(current_review_status)
             member_reviewer['allowed_to_update'] = c.allowed_to_update
             c.pull_request_set_reviewers_data_json['reviewers'].append(member_reviewer)
 
         c.pull_request_set_reviewers_data_json = json.dumps(c.pull_request_set_reviewers_data_json)
 
+        for observer_obj, member in pull_request_at_ver.observers():
+            member_observer = h.reviewer_as_json(
+                member, reasons=[], mandatory=False,
+                role=observer_obj.role,
+                user_group=observer_obj.rule_user_group_data()
+            )
+            member_observer['allowed_to_update'] = c.allowed_to_update
+            c.pull_request_set_observers_data_json['observers'].append(member_observer)
+
+        c.pull_request_set_observers_data_json = json.dumps(c.pull_request_set_observers_data_json)
+
         general_comments, inline_comments = \
             self.register_comments_vars(c, pull_request_latest, versions)
 
         # TODOs
         c.unresolved_comments = CommentsModel() \
             .get_pull_request_unresolved_todos(pull_request_latest)
         c.resolved_comments = CommentsModel() \
             .get_pull_request_resolved_todos(pull_request_latest)
 
         # if we use version, then do not show later comments
         # than current version
         display_inline_comments = collections.defaultdict(
             lambda: collections.defaultdict(list))
         for co in inline_comments:
             if c.at_version_num:
                 # pick comments that are at least UPTO given version, so we
                 # don't render comments for higher version
                 should_render = co.pull_request_version_id and \
                                 co.pull_request_version_id <= c.at_version_num
             else:
                 # showing all, for 'latest'
                 should_render = True
 
             if should_render:
                 display_inline_comments[co.f_path][co.line_no].append(co)
 
         # load diff data into template context, if we use compare mode then
         # diff is calculated based on changes between versions of PR
 
         source_repo = pull_request_at_ver.source_repo
         source_ref_id = pull_request_at_ver.source_ref_parts.commit_id
 
         target_repo = pull_request_at_ver.target_repo
         target_ref_id = pull_request_at_ver.target_ref_parts.commit_id
 
         if compare:
             # in compare switch the diff base to latest commit from prev version
             target_ref_id = prev_pull_request_display_obj.revisions[0]
 
         # despite opening commits for bookmarks/branches/tags, we always
         # convert this to rev to prevent changes after bookmark or branch change
         c.source_ref_type = 'rev'
         c.source_ref = source_ref_id
 
         c.target_ref_type = 'rev'
         c.target_ref = target_ref_id
 
         c.source_repo = source_repo
         c.target_repo = target_repo
 
         c.commit_ranges = []
         source_commit = EmptyCommit()
         target_commit = EmptyCommit()
         c.missing_requirements = False
 
         source_scm = source_repo.scm_instance()
         target_scm = target_repo.scm_instance()
 
         shadow_scm = None
         try:
             shadow_scm = pull_request_latest.get_shadow_repo()
         except Exception:
             log.debug('Failed to get shadow repo', exc_info=True)
         # try first the existing source_repo, and then shadow
         # repo if we can obtain one
         commits_source_repo = source_scm
         if shadow_scm:
             commits_source_repo = shadow_scm
 
         c.commits_source_repo = commits_source_repo
         c.ancestor = None  # set it to None, to hide it from PR view
 
         # empty version means latest, so we keep this to prevent
         # double caching
         version_normalized = version or PullRequest.LATEST_VER
         from_version_normalized = from_version or PullRequest.LATEST_VER
 
         cache_path = self.rhodecode_vcs_repo.get_create_shadow_cache_pr_path(target_repo)
         cache_file_path = diff_cache_exist(
             cache_path, 'pull_request', pull_request_id, version_normalized,
             from_version_normalized, source_ref_id, target_ref_id,
             hide_whitespace_changes, diff_context, c.fulldiff)
 
         caching_enabled = self._is_diff_cache_enabled(c.target_repo)
         force_recache = self.get_recache_flag()
 
         cached_diff = None
         if caching_enabled:
             cached_diff = load_cached_diff(cache_file_path)
 
         has_proper_commit_cache = (
                 cached_diff and cached_diff.get('commits')
                 and len(cached_diff.get('commits', [])) == 5
                 and cached_diff.get('commits')[0]
                 and cached_diff.get('commits')[3])
 
         if not force_recache and not c.range_diff_on and has_proper_commit_cache:
             diff_commit_cache = \
                 (ancestor_commit, commit_cache, missing_requirements,
                  source_commit, target_commit) = cached_diff['commits']
         else:
             # NOTE(marcink): we reach potentially unreachable errors when a PR has
             # merge errors resulting in potentially hidden commits in the shadow repo.
             maybe_unreachable = _merge_check.MERGE_CHECK in _merge_check.error_details \
                                 and _merge_check.merge_response
             maybe_unreachable = maybe_unreachable \
                                 and _merge_check.merge_response.metadata.get('unresolved_files')
             log.debug("Using unreachable commits due to MERGE_CHECK in merge simulation")
             diff_commit_cache = \
                 (ancestor_commit, commit_cache, missing_requirements,
                  source_commit, target_commit) = self.get_commits(
                     commits_source_repo,
                     pull_request_at_ver,
                     source_commit,
                     source_ref_id,
                     source_scm,
                     target_commit,
                     target_ref_id,
                     target_scm,
                 maybe_unreachable=maybe_unreachable)
 
         # register our commit range
         for comm in commit_cache.values():
             c.commit_ranges.append(comm)
 
         c.missing_requirements = missing_requirements
         c.ancestor_commit = ancestor_commit
         c.statuses = source_repo.statuses(
             [x.raw_id for x in c.commit_ranges])
 
         # auto collapse if we have more than limit
         collapse_limit = diffs.DiffProcessor._collapse_commits_over
         c.collapse_all_commits = len(c.commit_ranges) > collapse_limit
         c.compare_mode = compare
 
         # diff_limit is the old behavior, will cut off the whole diff
         # if the limit is applied  otherwise will just hide the
         # big files from the front-end
         diff_limit = c.visual.cut_off_limit_diff
         file_limit = c.visual.cut_off_limit_file
 
         c.missing_commits = False
         if (c.missing_requirements
             or isinstance(source_commit, EmptyCommit)
             or source_commit == target_commit):
 
             c.missing_commits = True
         else:
             c.inline_comments = display_inline_comments
 
             use_ancestor = True
             if from_version_normalized != version_normalized:
                 use_ancestor = False
 
             has_proper_diff_cache = cached_diff and cached_diff.get('commits')
             if not force_recache and has_proper_diff_cache:
                 c.diffset = cached_diff['diff']
             else:
                 try:
                     c.diffset = self._get_diffset(
                         c.source_repo.repo_name, commits_source_repo,
                         c.ancestor_commit,
                         source_ref_id, target_ref_id,
                         target_commit, source_commit,
                         diff_limit, file_limit, c.fulldiff,
                         hide_whitespace_changes, diff_context,
                         use_ancestor=use_ancestor
                     )
 
                     # save cached diff
                     if caching_enabled:
                         cache_diff(cache_file_path, c.diffset, diff_commit_cache)
                 except CommitDoesNotExistError:
                     log.exception('Failed to generate diffset')
                     c.missing_commits = True
 
             if not c.missing_commits:
 
                 c.limited_diff = c.diffset.limited_diff
 
                 # calculate removed files that are bound to comments
                 comment_deleted_files = [
                     fname for fname in display_inline_comments
                     if fname not in c.diffset.file_stats]
 
                 c.deleted_files_comments = collections.defaultdict(dict)
                 for fname, per_line_comments in display_inline_comments.items():
                     if fname in comment_deleted_files:
                         c.deleted_files_comments[fname]['stats'] = 0
                         c.deleted_files_comments[fname]['comments'] = list()
                         for lno, comments in per_line_comments.items():
                             c.deleted_files_comments[fname]['comments'].extend(comments)
 
                 # maybe calculate the range diff
                 if c.range_diff_on:
                     # TODO(marcink): set whitespace/context
                     context_lcl = 3
                     ign_whitespace_lcl = False
 
                     for commit in c.commit_ranges:
                         commit2 = commit
                         commit1 = commit.first_parent
 
                         range_diff_cache_file_path = diff_cache_exist(
                             cache_path, 'diff', commit.raw_id,
                             ign_whitespace_lcl, context_lcl, c.fulldiff)
 
                         cached_diff = None
                         if caching_enabled:
                             cached_diff = load_cached_diff(range_diff_cache_file_path)
 
                         has_proper_diff_cache = cached_diff and cached_diff.get('diff')
                         if not force_recache and has_proper_diff_cache:
                             diffset = cached_diff['diff']
                         else:
                             diffset = self._get_range_diffset(
                                 commits_source_repo, source_repo,
                                 commit1, commit2, diff_limit, file_limit,
                                 c.fulldiff, ign_whitespace_lcl, context_lcl
                             )
 
                         # save cached diff
                         if caching_enabled:
                             cache_diff(range_diff_cache_file_path, diffset, None)
 
                         c.changes[commit.raw_id] = diffset
 
         # this is a hack to properly display links, when creating PR, the
         # compare view and others uses different notation, and
         # compare_commits.mako renders links based on the target_repo.
         # We need to swap that here to generate it properly on the html side
         c.target_repo = c.source_repo
 
         c.commit_statuses = ChangesetStatus.STATUSES
 
         c.show_version_changes = not pr_closed
         if c.show_version_changes:
             cur_obj = pull_request_at_ver
             prev_obj = prev_pull_request_at_ver
 
             old_commit_ids = prev_obj.revisions
             new_commit_ids = cur_obj.revisions
             commit_changes = PullRequestModel()._calculate_commit_id_changes(
                 old_commit_ids, new_commit_ids)
             c.commit_changes_summary = commit_changes
 
             # calculate the diff for commits between versions
             c.commit_changes = []
 
             def mark(cs, fw):
                 return list(h.itertools.izip_longest([], cs, fillvalue=fw))
 
             for c_type, raw_id in mark(commit_changes.added, 'a') \
                                 + mark(commit_changes.removed, 'r') \
                                 + mark(commit_changes.common, 'c'):
 
                 if raw_id in commit_cache:
                     commit = commit_cache[raw_id]
                 else:
                     try:
                         commit = commits_source_repo.get_commit(raw_id)
                     except CommitDoesNotExistError:
                         # in case we fail extracting still use "dummy" commit
                         # for display in commit diff
                         commit = h.AttributeDict(
                             {'raw_id': raw_id,
                              'message': 'EMPTY or MISSING COMMIT'})
                 c.commit_changes.append([c_type, commit])
 
             # current user review statuses for each version
             c.review_versions = {}
             if self._rhodecode_user.user_id in c.allowed_reviewers:
                 for co in general_comments:
                     if co.author.user_id == self._rhodecode_user.user_id:
                         status = co.status_change
                         if status:
                             _ver_pr = status[0].comment.pull_request_version_id
                             c.review_versions[_ver_pr] = status[0]
 
         return self._get_template_context(c)
 
     def get_commits(
             self, commits_source_repo, pull_request_at_ver, source_commit,
             source_ref_id, source_scm, target_commit, target_ref_id, target_scm,
             maybe_unreachable=False):
 
         commit_cache = collections.OrderedDict()
         missing_requirements = False
 
         try:
             pre_load = ["author", "date", "message", "branch", "parents"]
 
             pull_request_commits = pull_request_at_ver.revisions
             log.debug('Loading %s commits from %s',
                       len(pull_request_commits), commits_source_repo)
 
             for rev in pull_request_commits:
                 comm = commits_source_repo.get_commit(commit_id=rev, pre_load=pre_load,
                                                       maybe_unreachable=maybe_unreachable)
                 commit_cache[comm.raw_id] = comm
 
             # Order here matters, we first need to get target, and then
             # the source
             target_commit = commits_source_repo.get_commit(
                 commit_id=safe_str(target_ref_id))
 
             source_commit = commits_source_repo.get_commit(
                 commit_id=safe_str(source_ref_id), maybe_unreachable=True)
         except CommitDoesNotExistError:
             log.warning('Failed to get commit from `{}` repo'.format(
                 commits_source_repo), exc_info=True)
         except RepositoryRequirementError:
             log.warning('Failed to get all required data from repo', exc_info=True)
             missing_requirements = True
 
         pr_ancestor_id = pull_request_at_ver.common_ancestor_id
 
         try:
             ancestor_commit = source_scm.get_commit(pr_ancestor_id)
         except Exception:
             ancestor_commit = None
 
         return ancestor_commit, commit_cache, missing_requirements, source_commit, target_commit
 
     def assure_not_empty_repo(self):
         _ = self.request.translate
 
         try:
             self.db_repo.scm_instance().get_commit()
         except EmptyRepositoryError:
             h.flash(h.literal(_('There are no commits yet')),
                     category='warning')
             raise HTTPFound(
                 h.route_path('repo_summary', repo_name=self.db_repo.repo_name))
 
     @LoginRequired()
     @NotAnonymous()
     @HasRepoPermissionAnyDecorator(
         'repository.read', 'repository.write', 'repository.admin')
     @view_config(
         route_name='pullrequest_new', request_method='GET',
         renderer='rhodecode:templates/pullrequests/pullrequest.mako')
     def pull_request_new(self):
         _ = self.request.translate
         c = self.load_default_context()
 
         self.assure_not_empty_repo()
         source_repo = self.db_repo
 
         commit_id = self.request.GET.get('commit')
         branch_ref = self.request.GET.get('branch')
         bookmark_ref = self.request.GET.get('bookmark')
 
         try:
             source_repo_data = PullRequestModel().generate_repo_data(
                 source_repo, commit_id=commit_id,
                 branch=branch_ref, bookmark=bookmark_ref,
                 translator=self.request.translate)
         except CommitDoesNotExistError as e:
             log.exception(e)
             h.flash(_('Commit does not exist'), 'error')
             raise HTTPFound(
                 h.route_path('pullrequest_new', repo_name=source_repo.repo_name))
 
         default_target_repo = source_repo
 
         if source_repo.parent and c.has_origin_repo_read_perm:
             parent_vcs_obj = source_repo.parent.scm_instance()
             if parent_vcs_obj and not parent_vcs_obj.is_empty():
                 # change default if we have a parent repo
                 default_target_repo = source_repo.parent
 
         target_repo_data = PullRequestModel().generate_repo_data(
             default_target_repo, translator=self.request.translate)
 
         selected_source_ref = source_repo_data['refs']['selected_ref']
         title_source_ref = ''
         if selected_source_ref:
             title_source_ref = selected_source_ref.split(':', 2)[1]
         c.default_title = PullRequestModel().generate_pullrequest_title(
             source=source_repo.repo_name,
             source_ref=title_source_ref,
             target=default_target_repo.repo_name
         )
 
         c.default_repo_data = {
             'source_repo_name': source_repo.repo_name,
             'source_refs_json': json.dumps(source_repo_data),
             'target_repo_name': default_target_repo.repo_name,
             'target_refs_json': json.dumps(target_repo_data),
         }
         c.default_source_ref = selected_source_ref
 
         return self._get_template_context(c)
 
     @LoginRequired()
     @NotAnonymous()
     @HasRepoPermissionAnyDecorator(
         'repository.read', 'repository.write', 'repository.admin')
     @view_config(
         route_name='pullrequest_repo_refs', request_method='GET',
         renderer='json_ext', xhr=True)
     def pull_request_repo_refs(self):
         self.load_default_context()
         target_repo_name = self.request.matchdict['target_repo_name']
         repo = Repository.get_by_repo_name(target_repo_name)
         if not repo:
             raise HTTPNotFound()
 
         target_perm = HasRepoPermissionAny(
             'repository.read', 'repository.write', 'repository.admin')(
             target_repo_name)
         if not target_perm:
             raise HTTPNotFound()
 
         return PullRequestModel().generate_repo_data(
             repo, translator=self.request.translate)
 
     @LoginRequired()
     @NotAnonymous()
     @HasRepoPermissionAnyDecorator(
         'repository.read', 'repository.write', 'repository.admin')
     @view_config(
         route_name='pullrequest_repo_targets', request_method='GET',
         renderer='json_ext', xhr=True)
     def pullrequest_repo_targets(self):
         _ = self.request.translate
         filter_query = self.request.GET.get('query')
 
         # get the parents
         parent_target_repos = []
         if self.db_repo.parent:
             parents_query = Repository.query() \
                 .order_by(func.length(Repository.repo_name)) \
                 .filter(Repository.fork_id == self.db_repo.parent.repo_id)
 
             if filter_query:
                 ilike_expression = u'%{}%'.format(safe_unicode(filter_query))
                 parents_query = parents_query.filter(
                     Repository.repo_name.ilike(ilike_expression))
             parents = parents_query.limit(20).all()
 
             for parent in parents:
                 parent_vcs_obj = parent.scm_instance()
                 if parent_vcs_obj and not parent_vcs_obj.is_empty():
                     parent_target_repos.append(parent)
 
         # get other forks, and repo itself
         query = Repository.query() \
             .order_by(func.length(Repository.repo_name)) \
             .filter(
                 or_(Repository.repo_id == self.db_repo.repo_id,  # repo itself
                     Repository.fork_id == self.db_repo.repo_id)  # forks of this repo
             )  \
             .filter(~Repository.repo_id.in_([x.repo_id for x in parent_target_repos]))
 
         if filter_query:
             ilike_expression = u'%{}%'.format(safe_unicode(filter_query))
             query = query.filter(Repository.repo_name.ilike(ilike_expression))
 
         limit = max(20 - len(parent_target_repos), 5)  # not less then 5
         target_repos = query.limit(limit).all()
 
         all_target_repos = target_repos + parent_target_repos
 
         repos = []
         # This checks permissions to the repositories
         for obj in ScmModel().get_repos(all_target_repos):
             repos.append({
                 'id': obj['name'],
                 'text': obj['name'],
                 'type': 'repo',
                 'repo_id': obj['dbrepo']['repo_id'],
                 'repo_type': obj['dbrepo']['repo_type'],
                 'private': obj['dbrepo']['private'],
 
             })
 
         data = {
             'more': False,
             'results': [{
                 'text': _('Repositories'),
                 'children': repos
             }] if repos else []
         }
         return data
 
     @LoginRequired()
     @NotAnonymous()
     @HasRepoPermissionAnyDecorator(
         'repository.read', 'repository.write', 'repository.admin')
     @view_config(
         route_name='pullrequest_comments', request_method='POST',
-        renderer='string', xhr=True)
+        renderer='string_html', xhr=True)
     def pullrequest_comments(self):
         self.load_default_context()
 
         pull_request = PullRequest.get_or_404(
             self.request.matchdict['pull_request_id'])
         pull_request_id = pull_request.pull_request_id
         version = self.request.GET.get('version')
 
         _render = self.request.get_partial_renderer(
             'rhodecode:templates/base/sidebar.mako')
         c = _render.get_call_context()
 
         (pull_request_latest,
          pull_request_at_ver,
          pull_request_display_obj,
          at_version) = PullRequestModel().get_pr_version(
             pull_request_id, version=version)
         versions = pull_request_display_obj.versions()
         latest_ver = PullRequest.get_pr_display_object(pull_request_latest, pull_request_latest)
         c.versions = versions + [latest_ver]
 
         c.at_version = at_version
         c.at_version_num = (at_version
                             if at_version and at_version != PullRequest.LATEST_VER
                             else None)
 
         self.register_comments_vars(c, pull_request_latest, versions)
         all_comments = c.inline_comments_flat + c.comments
 
         existing_ids = filter(
-            lambda e: e, map(safe_int, self.request.POST.getall('comments[]')))
+            lambda e: e, map(safe_int, aslist(self.request.POST.get('comments'))))
+
         return _render('comments_table', all_comments, len(all_comments),
                        existing_ids=existing_ids)
 
     @LoginRequired()
     @NotAnonymous()
     @HasRepoPermissionAnyDecorator(
         'repository.read', 'repository.write', 'repository.admin')
     @view_config(
         route_name='pullrequest_todos', request_method='POST',
-        renderer='string', xhr=True)
+        renderer='string_html', xhr=True)
     def pullrequest_todos(self):
         self.load_default_context()
 
         pull_request = PullRequest.get_or_404(
             self.request.matchdict['pull_request_id'])
         pull_request_id = pull_request.pull_request_id
         version = self.request.GET.get('version')
 
         _render = self.request.get_partial_renderer(
             'rhodecode:templates/base/sidebar.mako')
         c = _render.get_call_context()
         (pull_request_latest,
          pull_request_at_ver,
          pull_request_display_obj,
          at_version) = PullRequestModel().get_pr_version(
             pull_request_id, version=version)
         versions = pull_request_display_obj.versions()
         latest_ver = PullRequest.get_pr_display_object(pull_request_latest, pull_request_latest)
         c.versions = versions + [latest_ver]
 
         c.at_version = at_version
         c.at_version_num = (at_version
                             if at_version and at_version != PullRequest.LATEST_VER
                             else None)
 
         c.unresolved_comments = CommentsModel() \
             .get_pull_request_unresolved_todos(pull_request)
         c.resolved_comments = CommentsModel() \
             .get_pull_request_resolved_todos(pull_request)
 
         all_comments = c.unresolved_comments + c.resolved_comments
         existing_ids = filter(
             lambda e: e, map(safe_int, self.request.POST.getall('comments[]')))
         return _render('comments_table', all_comments, len(c.unresolved_comments),
                        todo_comments=True, existing_ids=existing_ids)
 
     @LoginRequired()
     @NotAnonymous()
     @HasRepoPermissionAnyDecorator(
         'repository.read', 'repository.write', 'repository.admin')
     @CSRFRequired()
     @view_config(
         route_name='pullrequest_create', request_method='POST',
         renderer=None)
     def pull_request_create(self):
         _ = self.request.translate
         self.assure_not_empty_repo()
         self.load_default_context()
 
         controls = peppercorn.parse(self.request.POST.items())
 
         try:
             form = PullRequestForm(
                 self.request.translate, self.db_repo.repo_id)()
             _form = form.to_python(controls)
         except formencode.Invalid as errors:
             if errors.error_dict.get('revisions'):
                 msg = 'Revisions: %s' % errors.error_dict['revisions']
             elif errors.error_dict.get('pullrequest_title'):
                 msg = errors.error_dict.get('pullrequest_title')
             else:
                 msg = _('Error creating pull request: {}').format(errors)
             log.exception(msg)
             h.flash(msg, 'error')
 
             # would rather just go back to form ...
             raise HTTPFound(
                 h.route_path('pullrequest_new', repo_name=self.db_repo_name))
 
         source_repo = _form['source_repo']
         source_ref = _form['source_ref']
         target_repo = _form['target_repo']
         target_ref = _form['target_ref']
         commit_ids = _form['revisions'][::-1]
         common_ancestor_id = _form['common_ancestor']
 
         # find the ancestor for this pr
         source_db_repo = Repository.get_by_repo_name(_form['source_repo'])
         target_db_repo = Repository.get_by_repo_name(_form['target_repo'])
 
         if not (source_db_repo or target_db_repo):
             h.flash(_('source_repo or target repo not found'), category='error')
             raise HTTPFound(
                 h.route_path('pullrequest_new', repo_name=self.db_repo_name))
 
         # re-check permissions again here
         # source_repo we must have read permissions
 
         source_perm = HasRepoPermissionAny(
             'repository.read', 'repository.write', 'repository.admin')(
             source_db_repo.repo_name)
         if not source_perm:
             msg = _('Not Enough permissions to source repo `{}`.'.format(
                 source_db_repo.repo_name))
             h.flash(msg, category='error')
             # copy the args back to redirect
             org_query = self.request.GET.mixed()
             raise HTTPFound(
                 h.route_path('pullrequest_new', repo_name=self.db_repo_name,
                              _query=org_query))
 
         # target repo we must have read permissions, and also later on
         # we want to check branch permissions here
         target_perm = HasRepoPermissionAny(
             'repository.read', 'repository.write', 'repository.admin')(
             target_db_repo.repo_name)
         if not target_perm:
             msg = _('Not Enough permissions to target repo `{}`.'.format(
                 target_db_repo.repo_name))
             h.flash(msg, category='error')
             # copy the args back to redirect
             org_query = self.request.GET.mixed()
             raise HTTPFound(
                 h.route_path('pullrequest_new', repo_name=self.db_repo_name,
                              _query=org_query))
 
         source_scm = source_db_repo.scm_instance()
         target_scm = target_db_repo.scm_instance()
 
         source_commit = source_scm.get_commit(source_ref.split(':')[-1])
         target_commit = target_scm.get_commit(target_ref.split(':')[-1])
 
         ancestor = source_scm.get_common_ancestor(
             source_commit.raw_id, target_commit.raw_id, target_scm)
 
         # recalculate target ref based on ancestor
         target_ref_type, target_ref_name, __ = _form['target_ref'].split(':')
         target_ref = ':'.join((target_ref_type, target_ref_name, ancestor))
 
-        get_default_reviewers_data, validate_default_reviewers = \
+        get_default_reviewers_data, validate_default_reviewers, validate_observers = \
             PullRequestModel().get_reviewer_functions()
 
         # recalculate reviewers logic, to make sure we can validate this
         reviewer_rules = get_default_reviewers_data(
             self._rhodecode_db_user, source_db_repo,
             source_commit, target_db_repo, target_commit)
 
-        given_reviewers = _form['review_members']
-        reviewers = validate_default_reviewers(
-            given_reviewers, reviewer_rules)
+        reviewers = validate_default_reviewers(_form['review_members'], reviewer_rules)
+        observers = validate_observers(_form['observer_members'], reviewer_rules)
 
         pullrequest_title = _form['pullrequest_title']
         title_source_ref = source_ref.split(':', 2)[1]
         if not pullrequest_title:
             pullrequest_title = PullRequestModel().generate_pullrequest_title(
                 source=source_repo,
                 source_ref=title_source_ref,
                 target=target_repo
             )
 
         description = _form['pullrequest_desc']
         description_renderer = _form['description_renderer']
 
         try:
             pull_request = PullRequestModel().create(
                 created_by=self._rhodecode_user.user_id,
                 source_repo=source_repo,
                 source_ref=source_ref,
                 target_repo=target_repo,
                 target_ref=target_ref,
                 revisions=commit_ids,
                 common_ancestor_id=common_ancestor_id,
                 reviewers=reviewers,
+                observers=observers,
                 title=pullrequest_title,
                 description=description,
                 description_renderer=description_renderer,
                 reviewer_data=reviewer_rules,
                 auth_user=self._rhodecode_user
             )
             Session().commit()
 
             h.flash(_('Successfully opened new pull request'),
                     category='success')
         except Exception:
             msg = _('Error occurred during creation of this pull request.')
             log.exception(msg)
             h.flash(msg, category='error')
 
             # copy the args back to redirect
             org_query = self.request.GET.mixed()
             raise HTTPFound(
                 h.route_path('pullrequest_new', repo_name=self.db_repo_name,
                              _query=org_query))
 
         raise HTTPFound(
             h.route_path('pullrequest_show', repo_name=target_repo,
                          pull_request_id=pull_request.pull_request_id))
 
     @LoginRequired()
     @NotAnonymous()
     @HasRepoPermissionAnyDecorator(
         'repository.read', 'repository.write', 'repository.admin')
     @CSRFRequired()
     @view_config(
         route_name='pullrequest_update', request_method='POST',
         renderer='json_ext')
     def pull_request_update(self):
         pull_request = PullRequest.get_or_404(
             self.request.matchdict['pull_request_id'])
         _ = self.request.translate
 
         c = self.load_default_context()
         redirect_url = None
 
         if pull_request.is_closed():
             log.debug('update: forbidden because pull request is closed')
             msg = _(u'Cannot update closed pull requests.')
             h.flash(msg, category='error')
             return {'response': True,
                     'redirect_url': redirect_url}
 
         is_state_changing = pull_request.is_state_changing()
         c.pr_broadcast_channel = '/repo${}$/pr/{}'.format(
             pull_request.target_repo.repo_name, pull_request.pull_request_id)
 
         # only owner or admin can update it
         allowed_to_update = PullRequestModel().check_user_update(
             pull_request, self._rhodecode_user)
+
         if allowed_to_update:
             controls = peppercorn.parse(self.request.POST.items())
             force_refresh = str2bool(self.request.POST.get('force_refresh'))
 
             if 'review_members' in controls:
                 self._update_reviewers(
+                    c,
                     pull_request, controls['review_members'],
-                    pull_request.reviewer_data)
+                    pull_request.reviewer_data,
+                    PullRequestReviewers.ROLE_REVIEWER)
+            elif 'observer_members' in controls:
+                self._update_reviewers(
+                    c,
+                    pull_request, controls['observer_members'],
+                    pull_request.reviewer_data,
+                    PullRequestReviewers.ROLE_OBSERVER)
             elif str2bool(self.request.POST.get('update_commits', 'false')):
                 if is_state_changing:
                     log.debug('commits update: forbidden because pull request is in state %s',
                               pull_request.pull_request_state)
                     msg = _(u'Cannot update pull requests commits in state other than `{}`. '
                             u'Current state is: `{}`').format(
                         PullRequest.STATE_CREATED, pull_request.pull_request_state)
                     h.flash(msg, category='error')
                     return {'response': True,
                             'redirect_url': redirect_url}
 
                 self._update_commits(c, pull_request)
                 if force_refresh:
                     redirect_url = h.route_path(
                         'pullrequest_show', repo_name=self.db_repo_name,
                         pull_request_id=pull_request.pull_request_id,
                         _query={"force_refresh": 1})
             elif str2bool(self.request.POST.get('edit_pull_request', 'false')):
                 self._edit_pull_request(pull_request)
             else:
+                log.error('Unhandled update data.')
                 raise HTTPBadRequest()
 
             return {'response': True,
                     'redirect_url': redirect_url}
         raise HTTPForbidden()
 
     def _edit_pull_request(self, pull_request):
+        """
+        Edit title and description
+        """
         _ = self.request.translate
 
         try:
             PullRequestModel().edit(
                 pull_request,
                 self.request.POST.get('title'),
                 self.request.POST.get('description'),
                 self.request.POST.get('description_renderer'),
                 self._rhodecode_user)
         except ValueError:
             msg = _(u'Cannot update closed pull requests.')
             h.flash(msg, category='error')
             return
         else:
             Session().commit()
 
         msg = _(u'Pull request title & description updated.')
         h.flash(msg, category='success')
         return
 
     def _update_commits(self, c, pull_request):
         _ = self.request.translate
 
         with pull_request.set_state(PullRequest.STATE_UPDATING):
             resp = PullRequestModel().update_commits(
                 pull_request, self._rhodecode_db_user)
 
         if resp.executed:
 
             if resp.target_changed and resp.source_changed:
                 changed = 'target and source repositories'
             elif resp.target_changed and not resp.source_changed:
                 changed = 'target repository'
             elif not resp.target_changed and resp.source_changed:
                 changed = 'source repository'
             else:
                 changed = 'nothing'
 
             msg = _(u'Pull request updated to "{source_commit_id}" with '
                     u'{count_added} added, {count_removed} removed commits. '
-                    u'Source of changes: {change_source}')
+                    u'Source of changes: {change_source}.')
             msg = msg.format(
                 source_commit_id=pull_request.source_ref_parts.commit_id,
                 count_added=len(resp.changes.added),
                 count_removed=len(resp.changes.removed),
                 change_source=changed)
             h.flash(msg, category='success')
-
-            message = msg + (
-                ' - <a onclick="window.location.reload()">'
-                '<strong>{}</strong></a>'.format(_('Reload page')))
-
-            message_obj = {
-                'message': message,
-                'level': 'success',
-                'topic': '/notifications'
-            }
-
-            channelstream.post_message(
-                c.pr_broadcast_channel, message_obj, self._rhodecode_user.username,
-                registry=self.request.registry)
+            self._pr_update_channelstream_push(c.pr_broadcast_channel, msg)
         else:
             msg = PullRequestModel.UPDATE_STATUS_MESSAGES[resp.reason]
             warning_reasons = [
                 UpdateFailureReason.NO_CHANGE,
                 UpdateFailureReason.WRONG_REF_TYPE,
             ]
             category = 'warning' if resp.reason in warning_reasons else 'error'
             h.flash(msg, category=category)
 
+    def _update_reviewers(self, c, pull_request, review_members, reviewer_rules, role):
+        _ = self.request.translate
+
+        get_default_reviewers_data, validate_default_reviewers, validate_observers = \
+            PullRequestModel().get_reviewer_functions()
+
+        if role == PullRequestReviewers.ROLE_REVIEWER:
+            try:
+                reviewers = validate_default_reviewers(review_members, reviewer_rules)
+            except ValueError as e:
+                log.error('Reviewers Validation: {}'.format(e))
+                h.flash(e, category='error')
+                return
+
+            old_calculated_status = pull_request.calculated_review_status()
+            PullRequestModel().update_reviewers(
+                pull_request, reviewers, self._rhodecode_user)
+
+            Session().commit()
+
+            msg = _('Pull request reviewers updated.')
+            h.flash(msg, category='success')
+            self._pr_update_channelstream_push(c.pr_broadcast_channel, msg)
+
+            # trigger status changed if change in reviewers changes the status
+            calculated_status = pull_request.calculated_review_status()
+            if old_calculated_status != calculated_status:
+                PullRequestModel().trigger_pull_request_hook(
+                    pull_request, self._rhodecode_user, 'review_status_change',
+                    data={'status': calculated_status})
+
+        elif role == PullRequestReviewers.ROLE_OBSERVER:
+            try:
+                observers = validate_observers(review_members, reviewer_rules)
+            except ValueError as e:
+                log.error('Observers Validation: {}'.format(e))
+                h.flash(e, category='error')
+                return
+
+            PullRequestModel().update_observers(
+                pull_request, observers, self._rhodecode_user)
+
+            Session().commit()
+            msg = _('Pull request observers updated.')
+            h.flash(msg, category='success')
+            self._pr_update_channelstream_push(c.pr_broadcast_channel, msg)
+
     @LoginRequired()
     @NotAnonymous()
     @HasRepoPermissionAnyDecorator(
         'repository.read', 'repository.write', 'repository.admin')
     @CSRFRequired()
     @view_config(
         route_name='pullrequest_merge', request_method='POST',
         renderer='json_ext')
     def pull_request_merge(self):
         """
         Merge will perform a server-side merge of the specified
         pull request, if the pull request is approved and mergeable.
         After successful merging, the pull request is automatically
         closed, with a relevant comment.
         """
         pull_request = PullRequest.get_or_404(
             self.request.matchdict['pull_request_id'])
         _ = self.request.translate
 
         if pull_request.is_state_changing():
             log.debug('show: forbidden because pull request is in state %s',
                       pull_request.pull_request_state)
             msg = _(u'Cannot merge pull requests in state other than `{}`. '
                     u'Current state is: `{}`').format(PullRequest.STATE_CREATED,
                                                       pull_request.pull_request_state)
             h.flash(msg, category='error')
             raise HTTPFound(
                 h.route_path('pullrequest_show',
                              repo_name=pull_request.target_repo.repo_name,
                              pull_request_id=pull_request.pull_request_id))
 
         self.load_default_context()
 
         with pull_request.set_state(PullRequest.STATE_UPDATING):
             check = MergeCheck.validate(
                 pull_request, auth_user=self._rhodecode_user,
                 translator=self.request.translate)
         merge_possible = not check.failed
 
         for err_type, error_msg in check.errors:
             h.flash(error_msg, category=err_type)
 
         if merge_possible:
             log.debug("Pre-conditions checked, trying to merge.")
             extras = vcs_operation_context(
                 self.request.environ, repo_name=pull_request.target_repo.repo_name,
                 username=self._rhodecode_db_user.username, action='push',
                 scm=pull_request.target_repo.repo_type)
             with pull_request.set_state(PullRequest.STATE_UPDATING):
                 self._merge_pull_request(
                     pull_request, self._rhodecode_db_user, extras)
         else:
             log.debug("Pre-conditions failed, NOT merging.")
 
         raise HTTPFound(
             h.route_path('pullrequest_show',
                          repo_name=pull_request.target_repo.repo_name,
                          pull_request_id=pull_request.pull_request_id))
 
     def _merge_pull_request(self, pull_request, user, extras):
         _ = self.request.translate
         merge_resp = PullRequestModel().merge_repo(pull_request, user, extras=extras)
 
         if merge_resp.executed:
             log.debug("The merge was successful, closing the pull request.")
             PullRequestModel().close_pull_request(
                 pull_request.pull_request_id, user)
             Session().commit()
             msg = _('Pull request was successfully merged and closed.')
             h.flash(msg, category='success')
         else:
             log.debug(
                 "The merge was not successful. Merge response: %s", merge_resp)
             msg = merge_resp.merge_status_message
             h.flash(msg, category='error')
 
-    def _update_reviewers(self, pull_request, review_members, reviewer_rules):
-        _ = self.request.translate
-
-        get_default_reviewers_data, validate_default_reviewers = \
-            PullRequestModel().get_reviewer_functions()
-
-        try:
-            reviewers = validate_default_reviewers(review_members, reviewer_rules)
-        except ValueError as e:
-            log.error('Reviewers Validation: {}'.format(e))
-            h.flash(e, category='error')
-            return
-
-        old_calculated_status = pull_request.calculated_review_status()
-        PullRequestModel().update_reviewers(
-            pull_request, reviewers, self._rhodecode_user)
-        h.flash(_('Pull request reviewers updated.'), category='success')
-        Session().commit()
-
-        # trigger status changed if change in reviewers changes the status
-        calculated_status = pull_request.calculated_review_status()
-        if old_calculated_status != calculated_status:
-            PullRequestModel().trigger_pull_request_hook(
-                pull_request, self._rhodecode_user, 'review_status_change',
-                data={'status': calculated_status})
-
     @LoginRequired()
     @NotAnonymous()
     @HasRepoPermissionAnyDecorator(
         'repository.read', 'repository.write', 'repository.admin')
     @CSRFRequired()
     @view_config(
         route_name='pullrequest_delete', request_method='POST',
         renderer='json_ext')
     def pull_request_delete(self):
         _ = self.request.translate
 
         pull_request = PullRequest.get_or_404(
             self.request.matchdict['pull_request_id'])
         self.load_default_context()
 
         pr_closed = pull_request.is_closed()
         allowed_to_delete = PullRequestModel().check_user_delete(
             pull_request, self._rhodecode_user) and not pr_closed
 
         # only owner can delete it !
         if allowed_to_delete:
             PullRequestModel().delete(pull_request, self._rhodecode_user)
             Session().commit()
             h.flash(_('Successfully deleted pull request'),
                     category='success')
             raise HTTPFound(h.route_path('pullrequest_show_all',
                                          repo_name=self.db_repo_name))
 
         log.warning('user %s tried to delete pull request without access',
                     self._rhodecode_user)
         raise HTTPNotFound()
 
     @LoginRequired()
     @NotAnonymous()
     @HasRepoPermissionAnyDecorator(
         'repository.read', 'repository.write', 'repository.admin')
     @CSRFRequired()
     @view_config(
         route_name='pullrequest_comment_create', request_method='POST',
         renderer='json_ext')
     def pull_request_comment_create(self):
         _ = self.request.translate
 
         pull_request = PullRequest.get_or_404(
             self.request.matchdict['pull_request_id'])
         pull_request_id = pull_request.pull_request_id
 
         if pull_request.is_closed():
             log.debug('comment: forbidden because pull request is closed')
             raise HTTPForbidden()
 
         allowed_to_comment = PullRequestModel().check_user_comment(
             pull_request, self._rhodecode_user)
         if not allowed_to_comment:
-            log.debug(
-                'comment: forbidden because pull request is from forbidden repo')
+            log.debug('comment: forbidden because pull request is from forbidden repo')
             raise HTTPForbidden()
 
         c = self.load_default_context()
 
         status = self.request.POST.get('changeset_status', None)
         text = self.request.POST.get('text')
         comment_type = self.request.POST.get('comment_type')
         resolves_comment_id = self.request.POST.get('resolves_comment_id', None)
         close_pull_request = self.request.POST.get('close_pull_request')
 
         # the logic here should work like following, if we submit close
         # pr comment, use `close_pull_request_with_comment` function
         # else handle regular comment logic
 
         if close_pull_request:
             # only owner or admin or person with write permissions
             allowed_to_close = PullRequestModel().check_user_update(
                 pull_request, self._rhodecode_user)
             if not allowed_to_close:
                 log.debug('comment: forbidden because not allowed to close '
                           'pull request %s', pull_request_id)
                 raise HTTPForbidden()
 
             # This also triggers `review_status_change`
             comment, status = PullRequestModel().close_pull_request_with_comment(
                 pull_request, self._rhodecode_user, self.db_repo, message=text,
                 auth_user=self._rhodecode_user)
             Session().flush()
 
             PullRequestModel().trigger_pull_request_hook(
                 pull_request, self._rhodecode_user, 'comment',
                 data={'comment': comment})
 
         else:
             # regular comment case, could be inline, or one with status.
             # for that one we check also permissions
 
             allowed_to_change_status = PullRequestModel().check_user_change_status(
                 pull_request, self._rhodecode_user)
 
             if status and allowed_to_change_status:
                 message = (_('Status change %(transition_icon)s %(status)s')
                            % {'transition_icon': '>',
                               'status': ChangesetStatus.get_status_lbl(status)})
                 text = text or message
 
             comment = CommentsModel().create(
                 text=text,
                 repo=self.db_repo.repo_id,
                 user=self._rhodecode_user.user_id,
                 pull_request=pull_request,
                 f_path=self.request.POST.get('f_path'),
                 line_no=self.request.POST.get('line'),
                 status_change=(ChangesetStatus.get_status_lbl(status)
                                if status and allowed_to_change_status else None),
                 status_change_type=(status
                                     if status and allowed_to_change_status else None),
                 comment_type=comment_type,
                 resolves_comment_id=resolves_comment_id,
                 auth_user=self._rhodecode_user
             )
 
             if allowed_to_change_status:
                 # calculate old status before we change it
                 old_calculated_status = pull_request.calculated_review_status()
 
                 # get status if set !
                 if status:
                     ChangesetStatusModel().set_status(
                         self.db_repo.repo_id,
                         status,
                         self._rhodecode_user.user_id,
                         comment,
                         pull_request=pull_request
                     )
 
                 Session().flush()
                 # this is somehow required to get access to some relationship
                 # loaded on comment
                 Session().refresh(comment)
 
                 PullRequestModel().trigger_pull_request_hook(
                     pull_request, self._rhodecode_user, 'comment',
                     data={'comment': comment})
 
                 # we now calculate the status of pull request, and based on that
                 # calculation we set the commits status
                 calculated_status = pull_request.calculated_review_status()
                 if old_calculated_status != calculated_status:
                     PullRequestModel().trigger_pull_request_hook(
                         pull_request, self._rhodecode_user, 'review_status_change',
                         data={'status': calculated_status})
 
         Session().commit()
 
         data = {
             'target_id': h.safeid(h.safe_unicode(
                 self.request.POST.get('f_path'))),
         }
         if comment:
             c.co = comment
             c.at_version_num = None
             rendered_comment = render(
                 'rhodecode:templates/changeset/changeset_comment_block.mako',
                 self._get_template_context(c), self.request)
 
             data.update(comment.get_dict())
             data.update({'rendered_text': rendered_comment})
 
         return data
 
     @LoginRequired()
     @NotAnonymous()
     @HasRepoPermissionAnyDecorator(
         'repository.read', 'repository.write', 'repository.admin')
     @CSRFRequired()
     @view_config(
         route_name='pullrequest_comment_delete', request_method='POST',
         renderer='json_ext')
     def pull_request_comment_delete(self):
         pull_request = PullRequest.get_or_404(
             self.request.matchdict['pull_request_id'])
 
         comment = ChangesetComment.get_or_404(
             self.request.matchdict['comment_id'])
         comment_id = comment.comment_id
 
         if comment.immutable:
             # don't allow deleting comments that are immutable
             raise HTTPForbidden()
 
         if pull_request.is_closed():
             log.debug('comment: forbidden because pull request is closed')
             raise HTTPForbidden()
 
         if not comment:
             log.debug('Comment with id:%s not found, skipping', comment_id)
             # comment already deleted in another call probably
             return True
 
         if comment.pull_request.is_closed():
             # don't allow deleting comments on closed pull request
             raise HTTPForbidden()
 
         is_repo_admin = h.HasRepoPermissionAny('repository.admin')(self.db_repo_name)
         super_admin = h.HasPermissionAny('hg.admin')()
         comment_owner = comment.author.user_id == self._rhodecode_user.user_id
         is_repo_comment = comment.repo.repo_name == self.db_repo_name
         comment_repo_admin = is_repo_admin and is_repo_comment
 
         if super_admin or comment_owner or comment_repo_admin:
             old_calculated_status = comment.pull_request.calculated_review_status()
             CommentsModel().delete(comment=comment, auth_user=self._rhodecode_user)
             Session().commit()
             calculated_status = comment.pull_request.calculated_review_status()
             if old_calculated_status != calculated_status:
                 PullRequestModel().trigger_pull_request_hook(
                     comment.pull_request, self._rhodecode_user, 'review_status_change',
                     data={'status': calculated_status})
             return True
         else:
             log.warning('No permissions for user %s to delete comment_id: %s',
                         self._rhodecode_db_user, comment_id)
             raise HTTPNotFound()
 
     @LoginRequired()
     @NotAnonymous()
     @HasRepoPermissionAnyDecorator(
         'repository.read', 'repository.write', 'repository.admin')
     @CSRFRequired()
     @view_config(
         route_name='pullrequest_comment_edit', request_method='POST',
         renderer='json_ext')
     def pull_request_comment_edit(self):
         self.load_default_context()
 
         pull_request = PullRequest.get_or_404(
             self.request.matchdict['pull_request_id']
         )
         comment = ChangesetComment.get_or_404(
             self.request.matchdict['comment_id']
         )
         comment_id = comment.comment_id
 
         if comment.immutable:
             # don't allow deleting comments that are immutable
             raise HTTPForbidden()
 
         if pull_request.is_closed():
             log.debug('comment: forbidden because pull request is closed')
             raise HTTPForbidden()
 
         if not comment:
             log.debug('Comment with id:%s not found, skipping', comment_id)
             # comment already deleted in another call probably
             return True
 
         if comment.pull_request.is_closed():
             # don't allow deleting comments on closed pull request
             raise HTTPForbidden()
 
         is_repo_admin = h.HasRepoPermissionAny('repository.admin')(self.db_repo_name)
         super_admin = h.HasPermissionAny('hg.admin')()
         comment_owner = comment.author.user_id == self._rhodecode_user.user_id
         is_repo_comment = comment.repo.repo_name == self.db_repo_name
         comment_repo_admin = is_repo_admin and is_repo_comment
 
         if super_admin or comment_owner or comment_repo_admin:
             text = self.request.POST.get('text')
             version = self.request.POST.get('version')
             if text == comment.text:
                 log.warning(
                     'Comment(PR): '
                     'Trying to create new version '
                     'with the same comment body {}'.format(
                         comment_id,
                     )
                 )
                 raise HTTPNotFound()
 
             if version.isdigit():
                 version = int(version)
             else:
                 log.warning(
                     'Comment(PR): Wrong version type {} {} '
                     'for comment {}'.format(
                         version,
                         type(version),
                         comment_id,
                     )
                 )
                 raise HTTPNotFound()
 
             try:
                 comment_history = CommentsModel().edit(
                     comment_id=comment_id,
                     text=text,
                     auth_user=self._rhodecode_user,
                     version=version,
                 )
             except CommentVersionMismatch:
                 raise HTTPConflict()
 
             if not comment_history:
                 raise HTTPNotFound()
 
             Session().commit()
 
             PullRequestModel().trigger_pull_request_hook(
                 pull_request, self._rhodecode_user, 'comment_edit',
                 data={'comment': comment})
 
             return {
                 'comment_history_id': comment_history.comment_history_id,
                 'comment_id': comment.comment_id,
                 'comment_version': comment_history.version,
                 'comment_author_username': comment_history.author.username,
                 'comment_author_gravatar': h.gravatar_url(comment_history.author.email, 16),
                 'comment_created_on': h.age_component(comment_history.created_on,
                                                       time_is_local=True),
             }
         else:
             log.warning('No permissions for user %s to edit comment_id: %s',
                         self._rhodecode_db_user, comment_id)
             raise HTTPNotFound()

rhodecode/config/middleware.py

@@ -1,763 +1,767 b''
 # -*- coding: utf-8 -*-
 
 # Copyright (C) 2010-2020 RhodeCode GmbH
 #
 # This program is free software: you can redistribute it and/or modify
 # it under the terms of the GNU Affero General Public License, version 3
 # (only), as published by the Free Software Foundation.
 #
 # 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 Affero General Public License
 # along with this program.  If not, see <http://www.gnu.org/licenses/>.
 #
 # This program is dual-licensed. If you wish to learn more about the
 # RhodeCode Enterprise Edition, including its added features, Support services,
 # and proprietary license terms, please see https://rhodecode.com/licenses/
 
 import os
 import sys
 import logging
 import collections
 import tempfile
 import time
 
 from paste.gzipper import make_gzip_middleware
 import pyramid.events
 from pyramid.wsgi import wsgiapp
 from pyramid.authorization import ACLAuthorizationPolicy
 from pyramid.config import Configurator
 from pyramid.settings import asbool, aslist
 from pyramid.httpexceptions import (
     HTTPException, HTTPError, HTTPInternalServerError, HTTPFound, HTTPNotFound)
 from pyramid.renderers import render_to_response
 
 from rhodecode.model import meta
 from rhodecode.config import patches
 from rhodecode.config import utils as config_utils
 from rhodecode.config.environment import load_pyramid_environment
 
 import rhodecode.events
 from rhodecode.lib.middleware.vcs import VCSMiddleware
 from rhodecode.lib.request import Request
 from rhodecode.lib.vcs import VCSCommunicationError
 from rhodecode.lib.exceptions import VCSServerUnavailable
 from rhodecode.lib.middleware.appenlight import wrap_in_appenlight_if_enabled
 from rhodecode.lib.middleware.https_fixup import HttpsFixup
 from rhodecode.lib.celerylib.loader import configure_celery
 from rhodecode.lib.plugins.utils import register_rhodecode_plugin
 from rhodecode.lib.utils2 import aslist as rhodecode_aslist, AttributeDict
 from rhodecode.lib.exc_tracking import store_exception
 from rhodecode.subscribers import (
     scan_repositories_if_enabled, write_js_routes_if_enabled,
     write_metadata_if_needed, write_usage_data, inject_app_settings)
 
 
 log = logging.getLogger(__name__)
 
 
 def is_http_error(response):
     # error which should have traceback
     return response.status_code > 499
 
 
 def should_load_all():
     """
     Returns if all application components should be loaded. In some cases it's
     desired to skip apps loading for faster shell script execution
     """
     ssh_cmd = os.environ.get('RC_CMD_SSH_WRAPPER')
     if ssh_cmd:
         return False
 
     return True
 
 
 def make_pyramid_app(global_config, **settings):
     """
     Constructs the WSGI application based on Pyramid.
 
     Specials:
 
     * The application can also be integrated like a plugin via the call to
       `includeme`. This is accompanied with the other utility functions which
       are called. Changing this should be done with great care to not break
       cases when these fragments are assembled from another place.
 
     """
 
     # Allows to use format style "{ENV_NAME}" placeholders in the configuration. It
     # will be replaced by the value of the environment variable "NAME" in this case.
     start_time = time.time()
 
     debug = asbool(global_config.get('debug'))
     if debug:
         enable_debug()
 
     environ = {'ENV_{}'.format(key): value for key, value in os.environ.items()}
 
     global_config = _substitute_values(global_config, environ)
     settings = _substitute_values(settings, environ)
 
     sanitize_settings_and_apply_defaults(global_config, settings)
 
     config = Configurator(settings=settings)
 
     # Apply compatibility patches
     patches.inspect_getargspec()
 
     load_pyramid_environment(global_config, settings)
 
     # Static file view comes first
     includeme_first(config)
 
     includeme(config)
 
     pyramid_app = config.make_wsgi_app()
     pyramid_app = wrap_app_in_wsgi_middlewares(pyramid_app, config)
     pyramid_app.config = config
 
     config.configure_celery(global_config['__file__'])
     # creating the app uses a connection - return it after we are done
     meta.Session.remove()
     total_time = time.time() - start_time
     log.info('Pyramid app `%s` created and configured in %.2fs',
              pyramid_app.func_name, total_time)
 
     return pyramid_app
 
 
 def not_found_view(request):
     """
     This creates the view which should be registered as not-found-view to
     pyramid.
     """
 
     if not getattr(request, 'vcs_call', None):
         # handle like regular case with our error_handler
         return error_handler(HTTPNotFound(), request)
 
     # handle not found view as a vcs call
     settings = request.registry.settings
     ae_client = getattr(request, 'ae_client', None)
     vcs_app = VCSMiddleware(
         HTTPNotFound(), request.registry, settings,
         appenlight_client=ae_client)
 
     return wsgiapp(vcs_app)(None, request)
 
 
 def error_handler(exception, request):
     import rhodecode
     from rhodecode.lib import helpers
 
     rhodecode_title = rhodecode.CONFIG.get('rhodecode_title') or 'RhodeCode'
 
     base_response = HTTPInternalServerError()
     # prefer original exception for the response since it may have headers set
     if isinstance(exception, HTTPException):
         base_response = exception
     elif isinstance(exception, VCSCommunicationError):
         base_response = VCSServerUnavailable()
 
     if is_http_error(base_response):
         log.exception(
             'error occurred handling this request for path: %s', request.path)
 
     error_explanation = base_response.explanation or str(base_response)
     if base_response.status_code == 404:
         error_explanation += " Optionally you don't have permission to access this page."
     c = AttributeDict()
     c.error_message = base_response.status
     c.error_explanation = error_explanation
     c.visual = AttributeDict()
 
     c.visual.rhodecode_support_url = (
         request.registry.settings.get('rhodecode_support_url') or
         request.route_url('rhodecode_support')
     )
     c.redirect_time = 0
     c.rhodecode_name = rhodecode_title
     if not c.rhodecode_name:
         c.rhodecode_name = 'Rhodecode'
 
     c.causes = []
     if is_http_error(base_response):
         c.causes.append('Server is overloaded.')
         c.causes.append('Server database connection is lost.')
         c.causes.append('Server expected unhandled error.')
 
     if hasattr(base_response, 'causes'):
         c.causes = base_response.causes
 
     c.messages = helpers.flash.pop_messages(request=request)
 
     exc_info = sys.exc_info()
     c.exception_id = id(exc_info)
     c.show_exception_id = isinstance(base_response, VCSServerUnavailable) \
                           or base_response.status_code > 499
     c.exception_id_url = request.route_url(
         'admin_settings_exception_tracker_show', exception_id=c.exception_id)
 
     if c.show_exception_id:
         store_exception(c.exception_id, exc_info)
 
     response = render_to_response(
         '/errors/error_document.mako', {'c': c, 'h': helpers}, request=request,
         response=base_response)
 
     return response
 
 
 def includeme_first(config):
     # redirect automatic browser favicon.ico requests to correct place
     def favicon_redirect(context, request):
         return HTTPFound(
             request.static_path('rhodecode:public/images/favicon.ico'))
 
     config.add_view(favicon_redirect, route_name='favicon')
     config.add_route('favicon', '/favicon.ico')
 
     def robots_redirect(context, request):
         return HTTPFound(
             request.static_path('rhodecode:public/robots.txt'))
 
     config.add_view(robots_redirect, route_name='robots')
     config.add_route('robots', '/robots.txt')
 
     config.add_static_view(
         '_static/deform', 'deform:static')
     config.add_static_view(
         '_static/rhodecode', path='rhodecode:public', cache_max_age=3600 * 24)
 
 
 def includeme(config):
     log.debug('Initializing main includeme from %s', os.path.basename(__file__))
     settings = config.registry.settings
     config.set_request_factory(Request)
 
     # plugin information
     config.registry.rhodecode_plugins = collections.OrderedDict()
 
     config.add_directive(
         'register_rhodecode_plugin', register_rhodecode_plugin)
 
     config.add_directive('configure_celery', configure_celery)
 
     if asbool(settings.get('appenlight', 'false')):
         config.include('appenlight_client.ext.pyramid_tween')
 
     load_all = should_load_all()
 
     # Includes which are required. The application would fail without them.
     config.include('pyramid_mako')
     config.include('rhodecode.lib.rc_beaker')
     config.include('rhodecode.lib.rc_cache')
 
     config.include('rhodecode.apps._base.navigation')
     config.include('rhodecode.apps._base.subscribers')
     config.include('rhodecode.tweens')
     config.include('rhodecode.authentication')
 
     if load_all:
         config.include('rhodecode.integrations')
 
     if load_all:
         # load CE authentication plugins
         config.include('rhodecode.authentication.plugins.auth_crowd')
         config.include('rhodecode.authentication.plugins.auth_headers')
         config.include('rhodecode.authentication.plugins.auth_jasig_cas')
         config.include('rhodecode.authentication.plugins.auth_ldap')
         config.include('rhodecode.authentication.plugins.auth_pam')
         config.include('rhodecode.authentication.plugins.auth_rhodecode')
         config.include('rhodecode.authentication.plugins.auth_token')
 
         # Auto discover authentication plugins and include their configuration.
         if asbool(settings.get('auth_plugin.import_legacy_plugins', 'true')):
             from rhodecode.authentication import discover_legacy_plugins
             discover_legacy_plugins(config)
 
     # apps
     if load_all:
         config.include('rhodecode.apps._base')
         config.include('rhodecode.apps.hovercards')
         config.include('rhodecode.apps.ops')
         config.include('rhodecode.apps.admin')
         config.include('rhodecode.apps.channelstream')
         config.include('rhodecode.apps.file_store')
         config.include('rhodecode.apps.login')
         config.include('rhodecode.apps.home')
         config.include('rhodecode.apps.journal')
         config.include('rhodecode.apps.repository')
         config.include('rhodecode.apps.repo_group')
         config.include('rhodecode.apps.user_group')
         config.include('rhodecode.apps.search')
         config.include('rhodecode.apps.user_profile')
         config.include('rhodecode.apps.user_group_profile')
         config.include('rhodecode.apps.my_account')
         config.include('rhodecode.apps.svn_support')
         config.include('rhodecode.apps.ssh_support')
         config.include('rhodecode.apps.gist')
         config.include('rhodecode.apps.debug_style')
         config.include('rhodecode.api')
 
     config.add_route('rhodecode_support', 'https://rhodecode.com/help/', static=True)
     config.add_translation_dirs('rhodecode:i18n/')
     settings['default_locale_name'] = settings.get('lang', 'en')
 
     # Add subscribers.
     if load_all:
         config.add_subscriber(inject_app_settings,
                               pyramid.events.ApplicationCreated)
         config.add_subscriber(scan_repositories_if_enabled,
                               pyramid.events.ApplicationCreated)
         config.add_subscriber(write_metadata_if_needed,
                               pyramid.events.ApplicationCreated)
         config.add_subscriber(write_usage_data,
                               pyramid.events.ApplicationCreated)
         config.add_subscriber(write_js_routes_if_enabled,
                               pyramid.events.ApplicationCreated)
 
     # request custom methods
     config.add_request_method(
         'rhodecode.lib.partial_renderer.get_partial_renderer',
         'get_partial_renderer')
 
     config.add_request_method(
         'rhodecode.lib.request_counter.get_request_counter',
         'request_count')
 
     # Set the authorization policy.
     authz_policy = ACLAuthorizationPolicy()
     config.set_authorization_policy(authz_policy)
 
     # Set the default renderer for HTML templates to mako.
     config.add_mako_renderer('.html')
 
     config.add_renderer(
         name='json_ext',
         factory='rhodecode.lib.ext_json_renderer.pyramid_ext_json')
 
+    config.add_renderer(
+        name='string_html',
+        factory='rhodecode.lib.string_renderer.html')
+
     # include RhodeCode plugins
     includes = aslist(settings.get('rhodecode.includes', []))
     for inc in includes:
         config.include(inc)
 
     # custom not found view, if our pyramid app doesn't know how to handle
     # the request pass it to potential VCS handling ap
     config.add_notfound_view(not_found_view)
     if not settings.get('debugtoolbar.enabled', False):
         # disabled debugtoolbar handle all exceptions via the error_handlers
         config.add_view(error_handler, context=Exception)
 
     # all errors including 403/404/50X
     config.add_view(error_handler, context=HTTPError)
 
 
 def wrap_app_in_wsgi_middlewares(pyramid_app, config):
     """
     Apply outer WSGI middlewares around the application.
     """
     registry = config.registry
     settings = registry.settings
 
     # enable https redirects based on HTTP_X_URL_SCHEME set by proxy
     pyramid_app = HttpsFixup(pyramid_app, settings)
 
     pyramid_app, _ae_client = wrap_in_appenlight_if_enabled(
         pyramid_app, settings)
     registry.ae_client = _ae_client
 
     if settings['gzip_responses']:
         pyramid_app = make_gzip_middleware(
             pyramid_app, settings, compress_level=1)
 
     # this should be the outer most middleware in the wsgi stack since
     # middleware like Routes make database calls
     def pyramid_app_with_cleanup(environ, start_response):
         try:
             return pyramid_app(environ, start_response)
         finally:
             # Dispose current database session and rollback uncommitted
             # transactions.
             meta.Session.remove()
 
             # In a single threaded mode server, on non sqlite db we should have
             # '0 Current Checked out connections' at the end of a request,
             # if not, then something, somewhere is leaving a connection open
             pool = meta.Base.metadata.bind.engine.pool
             log.debug('sa pool status: %s', pool.status())
             log.debug('Request processing finalized')
 
     return pyramid_app_with_cleanup
 
 
 def sanitize_settings_and_apply_defaults(global_config, settings):
     """
     Applies settings defaults and does all type conversion.
 
     We would move all settings parsing and preparation into this place, so that
     we have only one place left which deals with this part. The remaining parts
     of the application would start to rely fully on well prepared settings.
 
     This piece would later be split up per topic to avoid a big fat monster
     function.
     """
 
     settings.setdefault('rhodecode.edition', 'Community Edition')
 
     if 'mako.default_filters' not in settings:
         # set custom default filters if we don't have it defined
         settings['mako.imports'] = 'from rhodecode.lib.base import h_filter'
         settings['mako.default_filters'] = 'h_filter'
 
     if 'mako.directories' not in settings:
         mako_directories = settings.setdefault('mako.directories', [
             # Base templates of the original application
             'rhodecode:templates',
         ])
         log.debug(
             "Using the following Mako template directories: %s",
             mako_directories)
 
     # NOTE(marcink): fix redis requirement for schema of connection since 3.X
     if 'beaker.session.type' in settings and settings['beaker.session.type'] == 'ext:redis':
         raw_url = settings['beaker.session.url']
         if not raw_url.startswith(('redis://', 'rediss://', 'unix://')):
             settings['beaker.session.url'] = 'redis://' + raw_url
 
     # Default includes, possible to change as a user
     pyramid_includes = settings.setdefault('pyramid.includes', [])
     log.debug(
         "Using the following pyramid.includes: %s",
         pyramid_includes)
 
     # TODO: johbo: Re-think this, usually the call to config.include
     # should allow to pass in a prefix.
     settings.setdefault('rhodecode.api.url', '/_admin/api')
     settings.setdefault('__file__', global_config.get('__file__'))
 
     # Sanitize generic settings.
     _list_setting(settings, 'default_encoding', 'UTF-8')
     _bool_setting(settings, 'is_test', 'false')
     _bool_setting(settings, 'gzip_responses', 'false')
 
     # Call split out functions that sanitize settings for each topic.
     _sanitize_appenlight_settings(settings)
     _sanitize_vcs_settings(settings)
     _sanitize_cache_settings(settings)
 
     # configure instance id
     config_utils.set_instance_id(settings)
 
     return settings
 
 
 def enable_debug():
     """
     Helper to enable debug on running instance
     :return:
     """
     import tempfile
     import textwrap
     import logging.config
 
     ini_template = textwrap.dedent("""
     #####################################
     ### DEBUG LOGGING CONFIGURATION  ####
     #####################################
     [loggers]
     keys = root, sqlalchemy, beaker, celery, rhodecode, ssh_wrapper
 
     [handlers]
     keys = console, console_sql
 
     [formatters]
     keys = generic, color_formatter, color_formatter_sql
 
     #############
     ## LOGGERS ##
     #############
     [logger_root]
     level = NOTSET
     handlers = console
 
     [logger_sqlalchemy]
     level = INFO
     handlers = console_sql
     qualname = sqlalchemy.engine
     propagate = 0
 
     [logger_beaker]
     level = DEBUG
     handlers =
     qualname = beaker.container
     propagate = 1
 
     [logger_rhodecode]
     level = DEBUG
     handlers =
     qualname = rhodecode
     propagate = 1
 
     [logger_ssh_wrapper]
     level = DEBUG
     handlers =
     qualname = ssh_wrapper
     propagate = 1
 
     [logger_celery]
     level = DEBUG
     handlers =
     qualname = celery
 
 
     ##############
     ## HANDLERS ##
     ##############
 
     [handler_console]
     class = StreamHandler
     args = (sys.stderr, )
     level = DEBUG
     formatter = color_formatter
 
     [handler_console_sql]
     # "level = DEBUG" logs SQL queries and results.
     # "level = INFO" logs SQL queries.
     # "level = WARN" logs neither.  (Recommended for production systems.)
     class = StreamHandler
     args = (sys.stderr, )
     level = WARN
     formatter = color_formatter_sql
 
     ################
     ## FORMATTERS ##
     ################
 
     [formatter_generic]
     class = rhodecode.lib.logging_formatter.ExceptionAwareFormatter
     format = %(asctime)s.%(msecs)03d [%(process)d] %(levelname)-5.5s [%(name)s] %(message)s | %(req_id)s
     datefmt = %Y-%m-%d %H:%M:%S
 
     [formatter_color_formatter]
     class = rhodecode.lib.logging_formatter.ColorRequestTrackingFormatter
     format = %(asctime)s.%(msecs)03d [%(process)d] %(levelname)-5.5s [%(name)s] %(message)s | %(req_id)s
     datefmt = %Y-%m-%d %H:%M:%S
 
     [formatter_color_formatter_sql]
     class = rhodecode.lib.logging_formatter.ColorFormatterSql
     format = %(asctime)s.%(msecs)03d [%(process)d] %(levelname)-5.5s [%(name)s] %(message)s
     datefmt = %Y-%m-%d %H:%M:%S    
     """)
 
     with tempfile.NamedTemporaryFile(prefix='rc_debug_logging_', suffix='.ini',
                                      delete=False) as f:
         log.info('Saved Temporary DEBUG config at %s', f.name)
         f.write(ini_template)
 
     logging.config.fileConfig(f.name)
     log.debug('DEBUG MODE ON')
     os.remove(f.name)
 
 
 def _sanitize_appenlight_settings(settings):
     _bool_setting(settings, 'appenlight', 'false')
 
 
 def _sanitize_vcs_settings(settings):
     """
     Applies settings defaults and does type conversion for all VCS related
     settings.
     """
     _string_setting(settings, 'vcs.svn.compatible_version', '')
     _string_setting(settings, 'vcs.hooks.protocol', 'http')
     _string_setting(settings, 'vcs.hooks.host', '127.0.0.1')
     _string_setting(settings, 'vcs.scm_app_implementation', 'http')
     _string_setting(settings, 'vcs.server', '')
     _string_setting(settings, 'vcs.server.protocol', 'http')
     _bool_setting(settings, 'startup.import_repos', 'false')
     _bool_setting(settings, 'vcs.hooks.direct_calls', 'false')
     _bool_setting(settings, 'vcs.server.enable', 'true')
     _bool_setting(settings, 'vcs.start_server', 'false')
     _list_setting(settings, 'vcs.backends', 'hg, git, svn')
     _int_setting(settings, 'vcs.connection_timeout', 3600)
 
     # Support legacy values of vcs.scm_app_implementation. Legacy
     # configurations may use 'rhodecode.lib.middleware.utils.scm_app_http', or
     # disabled since 4.13 'vcsserver.scm_app' which is now mapped to 'http'.
     scm_app_impl = settings['vcs.scm_app_implementation']
     if scm_app_impl in ['rhodecode.lib.middleware.utils.scm_app_http', 'vcsserver.scm_app']:
         settings['vcs.scm_app_implementation'] = 'http'
 
 
 def _sanitize_cache_settings(settings):
     temp_store = tempfile.gettempdir()
     default_cache_dir = os.path.join(temp_store, 'rc_cache')
 
     # save default, cache dir, and use it for all backends later.
     default_cache_dir = _string_setting(
         settings,
         'cache_dir',
         default_cache_dir, lower=False, default_when_empty=True)
 
     # ensure we have our dir created
     if not os.path.isdir(default_cache_dir):
         os.makedirs(default_cache_dir, mode=0o755)
 
     # exception store cache
     _string_setting(
         settings,
         'exception_tracker.store_path',
         temp_store, lower=False, default_when_empty=True)
     _bool_setting(
         settings,
         'exception_tracker.send_email',
         'false')
     _string_setting(
         settings,
         'exception_tracker.email_prefix',
         '[RHODECODE ERROR]', lower=False, default_when_empty=True)
 
     # cache_perms
     _string_setting(
         settings,
         'rc_cache.cache_perms.backend',
         'dogpile.cache.rc.file_namespace', lower=False)
     _int_setting(
         settings,
         'rc_cache.cache_perms.expiration_time',
         60)
     _string_setting(
         settings,
         'rc_cache.cache_perms.arguments.filename',
         os.path.join(default_cache_dir, 'rc_cache_1'), lower=False)
 
     # cache_repo
     _string_setting(
         settings,
         'rc_cache.cache_repo.backend',
         'dogpile.cache.rc.file_namespace', lower=False)
     _int_setting(
         settings,
         'rc_cache.cache_repo.expiration_time',
         60)
     _string_setting(
         settings,
         'rc_cache.cache_repo.arguments.filename',
         os.path.join(default_cache_dir, 'rc_cache_2'), lower=False)
 
     # cache_license
     _string_setting(
         settings,
         'rc_cache.cache_license.backend',
         'dogpile.cache.rc.file_namespace', lower=False)
     _int_setting(
         settings,
         'rc_cache.cache_license.expiration_time',
         5*60)
     _string_setting(
         settings,
         'rc_cache.cache_license.arguments.filename',
         os.path.join(default_cache_dir, 'rc_cache_3'), lower=False)
 
     # cache_repo_longterm memory, 96H
     _string_setting(
         settings,
         'rc_cache.cache_repo_longterm.backend',
         'dogpile.cache.rc.memory_lru', lower=False)
     _int_setting(
         settings,
         'rc_cache.cache_repo_longterm.expiration_time',
         345600)
     _int_setting(
         settings,
         'rc_cache.cache_repo_longterm.max_size',
         10000)
 
     # sql_cache_short
     _string_setting(
         settings,
         'rc_cache.sql_cache_short.backend',
         'dogpile.cache.rc.memory_lru', lower=False)
     _int_setting(
         settings,
         'rc_cache.sql_cache_short.expiration_time',
         30)
     _int_setting(
         settings,
         'rc_cache.sql_cache_short.max_size',
         10000)
 
 
 def _int_setting(settings, name, default):
     settings[name] = int(settings.get(name, default))
     return settings[name]
 
 
 def _bool_setting(settings, name, default):
     input_val = settings.get(name, default)
     if isinstance(input_val, unicode):
         input_val = input_val.encode('utf8')
     settings[name] = asbool(input_val)
     return settings[name]
 
 
 def _list_setting(settings, name, default):
     raw_value = settings.get(name, default)
 
     old_separator = ','
     if old_separator in raw_value:
         # If we get a comma separated list, pass it to our own function.
         settings[name] = rhodecode_aslist(raw_value, sep=old_separator)
     else:
         # Otherwise we assume it uses pyramids space/newline separation.
         settings[name] = aslist(raw_value)
     return settings[name]
 
 
 def _string_setting(settings, name, default, lower=True, default_when_empty=False):
     value = settings.get(name, default)
 
     if default_when_empty and not value:
         # use default value when value is empty
         value = default
 
     if lower:
         value = value.lower()
     settings[name] = value
     return settings[name]
 
 
 def _substitute_values(mapping, substitutions):
     result = {}
 
     try:
         for key, value in mapping.items():
             # initialize without substitution first
             result[key] = value
 
             # Note: Cannot use regular replacements, since they would clash
             # with the implementation of ConfigParser. Using "format" instead.
             try:
                 result[key] = value.format(**substitutions)
             except KeyError as e:
                 env_var = '{}'.format(e.args[0])
 
                 msg = 'Failed to substitute: `{key}={{{var}}}` with environment entry. ' \
                       'Make sure your environment has {var} set, or remove this ' \
                       'variable from config file'.format(key=key, var=env_var)
 
                 if env_var.startswith('ENV_'):
                     raise ValueError(msg)
                 else:
                     log.warning(msg)
 
     except ValueError as e:
         log.warning('Failed to substitute ENV variable: %s', e)
         result = mapping
 
     return result

rhodecode/lib/audit_logger.py

@@ -1,295 +1,298 b''
 # -*- coding: utf-8 -*-
 
 # Copyright (C) 2017-2020 RhodeCode GmbH
 #
 # This program is free software: you can redistribute it and/or modify
 # it under the terms of the GNU Affero General Public License, version 3
 # (only), as published by the Free Software Foundation.
 #
 # 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 Affero General Public License
 # along with this program.  If not, see <http://www.gnu.org/licenses/>.
 #
 # This program is dual-licensed. If you wish to learn more about the
 # RhodeCode Enterprise Edition, including its added features, Support services,
 # and proprietary license terms, please see https://rhodecode.com/licenses/
 
 import logging
 import datetime
 
 from rhodecode.lib.jsonalchemy import JsonRaw
 from rhodecode.model import meta
 from rhodecode.model.db import User, UserLog, Repository
 
 
 log = logging.getLogger(__name__)
 
 # action as key, and expected action_data as value
 ACTIONS_V1 = {
     'user.login.success': {'user_agent': ''},
     'user.login.failure': {'user_agent': ''},
     'user.logout': {'user_agent': ''},
     'user.register': {},
     'user.password.reset_request': {},
     'user.push': {'user_agent': '', 'commit_ids': []},
     'user.pull': {'user_agent': ''},
 
     'user.create': {'data': {}},
     'user.delete': {'old_data': {}},
     'user.edit': {'old_data': {}},
     'user.edit.permissions': {},
     'user.edit.ip.add': {'ip': {}, 'user': {}},
     'user.edit.ip.delete': {'ip': {}, 'user': {}},
     'user.edit.token.add': {'token': {}, 'user': {}},
     'user.edit.token.delete': {'token': {}, 'user': {}},
     'user.edit.email.add': {'email': ''},
     'user.edit.email.delete': {'email': ''},
     'user.edit.ssh_key.add': {'token': {}, 'user': {}},
     'user.edit.ssh_key.delete': {'token': {}, 'user': {}},
     'user.edit.password_reset.enabled': {},
     'user.edit.password_reset.disabled': {},
 
     'user_group.create': {'data': {}},
     'user_group.delete': {'old_data': {}},
     'user_group.edit': {'old_data': {}},
     'user_group.edit.permissions': {},
     'user_group.edit.member.add': {'user': {}},
     'user_group.edit.member.delete': {'user': {}},
 
     'repo.create': {'data': {}},
     'repo.fork': {'data': {}},
     'repo.edit': {'old_data': {}},
     'repo.edit.permissions': {},
     'repo.edit.permissions.branch': {},
     'repo.archive': {'old_data': {}},
     'repo.delete': {'old_data': {}},
 
     'repo.archive.download': {'user_agent': '', 'archive_name': '',
                               'archive_spec': '', 'archive_cached': ''},
 
     'repo.permissions.branch_rule.create': {},
     'repo.permissions.branch_rule.edit': {},
     'repo.permissions.branch_rule.delete': {},
 
     'repo.pull_request.create': '',
     'repo.pull_request.edit': '',
     'repo.pull_request.delete': '',
     'repo.pull_request.close': '',
     'repo.pull_request.merge': '',
     'repo.pull_request.vote': '',
     'repo.pull_request.comment.create': '',
     'repo.pull_request.comment.edit': '',
     'repo.pull_request.comment.delete': '',
 
     'repo.pull_request.reviewer.add': '',
     'repo.pull_request.reviewer.delete': '',
 
+    'repo.pull_request.observer.add': '',
+    'repo.pull_request.observer.delete': '',
+
     'repo.commit.strip': {'commit_id': ''},
     'repo.commit.comment.create': {'data': {}},
     'repo.commit.comment.delete': {'data': {}},
     'repo.commit.comment.edit': {'data': {}},
     'repo.commit.vote': '',
 
     'repo.artifact.add': '',
     'repo.artifact.delete': '',
 
     'repo_group.create': {'data': {}},
     'repo_group.edit': {'old_data': {}},
     'repo_group.edit.permissions': {},
     'repo_group.delete': {'old_data': {}},
 }
 
 ACTIONS = ACTIONS_V1
 
 SOURCE_WEB = 'source_web'
 SOURCE_API = 'source_api'
 
 
 class UserWrap(object):
     """
     Fake object used to imitate AuthUser
     """
 
     def __init__(self, user_id=None, username=None, ip_addr=None):
         self.user_id = user_id
         self.username = username
         self.ip_addr = ip_addr
 
 
 class RepoWrap(object):
     """
     Fake object used to imitate RepoObject that audit logger requires
     """
 
     def __init__(self, repo_id=None, repo_name=None):
         self.repo_id = repo_id
         self.repo_name = repo_name
 
 
 def _store_log(action_name, action_data, user_id, username, user_data,
                ip_address, repository_id, repository_name):
     user_log = UserLog()
     user_log.version = UserLog.VERSION_2
 
     user_log.action = action_name
     user_log.action_data = action_data or JsonRaw(u'{}')
 
     user_log.user_ip = ip_address
 
     user_log.user_id = user_id
     user_log.username = username
     user_log.user_data = user_data or JsonRaw(u'{}')
 
     user_log.repository_id = repository_id
     user_log.repository_name = repository_name
 
     user_log.action_date = datetime.datetime.now()
 
     return user_log
 
 
 def store_web(*args, **kwargs):
     action_data = {}
     org_action_data = kwargs.pop('action_data', {})
     action_data.update(org_action_data)
     action_data['source'] = SOURCE_WEB
     kwargs['action_data'] = action_data
 
     return store(*args, **kwargs)
 
 
 def store_api(*args, **kwargs):
     action_data = {}
     org_action_data = kwargs.pop('action_data', {})
     action_data.update(org_action_data)
     action_data['source'] = SOURCE_API
     kwargs['action_data'] = action_data
 
     return store(*args, **kwargs)
 
 
 def store(action, user, action_data=None, user_data=None, ip_addr=None,
           repo=None, sa_session=None, commit=False):
     """
     Audit logger for various actions made by users, typically this
     results in a call such::
 
         from rhodecode.lib import audit_logger
 
         audit_logger.store(
             'repo.edit', user=self._rhodecode_user)
         audit_logger.store(
             'repo.delete', action_data={'data': repo_data},
             user=audit_logger.UserWrap(username='itried-login', ip_addr='8.8.8.8'))
 
         # repo action
         audit_logger.store(
             'repo.delete',
             user=audit_logger.UserWrap(username='itried-login', ip_addr='8.8.8.8'),
             repo=audit_logger.RepoWrap(repo_name='some-repo'))
 
         # repo action, when we know and have the repository object already
         audit_logger.store(
             'repo.delete', action_data={'source': audit_logger.SOURCE_WEB, },
             user=self._rhodecode_user,
             repo=repo_object)
 
         # alternative wrapper to the above
         audit_logger.store_web(
             'repo.delete', action_data={},
             user=self._rhodecode_user,
             repo=repo_object)
 
         # without an user ?
         audit_logger.store(
             'user.login.failure',
             user=audit_logger.UserWrap(
                     username=self.request.params.get('username'),
                     ip_addr=self.request.remote_addr))
 
     """
     from rhodecode.lib.utils2 import safe_unicode
     from rhodecode.lib.auth import AuthUser
 
     action_spec = ACTIONS.get(action, None)
     if action_spec is None:
         raise ValueError('Action `{}` is not supported'.format(action))
 
     if not sa_session:
         sa_session = meta.Session()
 
     try:
         username = getattr(user, 'username', None)
         if not username:
             pass
 
         user_id = getattr(user, 'user_id', None)
         if not user_id:
             # maybe we have username ? Try to figure user_id from username
             if username:
                 user_id = getattr(
                     User.get_by_username(username), 'user_id', None)
 
         ip_addr = ip_addr or getattr(user, 'ip_addr', None)
         if not ip_addr:
             pass
 
         if not user_data:
             # try to get this from the auth user
             if isinstance(user, AuthUser):
                 user_data = {
                     'username': user.username,
                     'email': user.email,
                 }
 
         repository_name = getattr(repo, 'repo_name', None)
         repository_id = getattr(repo, 'repo_id', None)
         if not repository_id:
             # maybe we have repo_name ? Try to figure repo_id from repo_name
             if repository_name:
                 repository_id = getattr(
                     Repository.get_by_repo_name(repository_name), 'repo_id', None)
 
         action_name = safe_unicode(action)
         ip_address = safe_unicode(ip_addr)
 
         with sa_session.no_autoflush:
             update_user_last_activity(sa_session, user_id)
 
             user_log = _store_log(
                 action_name=action_name,
                 action_data=action_data or {},
                 user_id=user_id,
                 username=username,
                 user_data=user_data or {},
                 ip_address=ip_address,
                 repository_id=repository_id,
                 repository_name=repository_name
             )
 
             sa_session.add(user_log)
 
             if commit:
                 sa_session.commit()
 
         entry_id = user_log.entry_id or ''
         log.info('AUDIT[%s]: Logging action: `%s` by user:id:%s[%s] ip:%s',
                  entry_id, action_name, user_id, username, ip_address)
 
     except Exception:
         log.exception('AUDIT: failed to store audit log')
 
 
 def update_user_last_activity(sa_session, user_id):
     _last_activity = datetime.datetime.now()
     try:
         sa_session.query(User).filter(User.user_id == user_id).update(
             {"last_activity": _last_activity})
         log.debug(
             'updated user `%s` last activity to:%s', user_id, _last_activity)
     except Exception:
         log.exception("Failed last activity update")

rhodecode/lib/helpers.py

@@ -1,2113 +1,2117 b''
 # -*- coding: utf-8 -*-
 
 # Copyright (C) 2010-2020 RhodeCode GmbH
 #
 # This program is free software: you can redistribute it and/or modify
 # it under the terms of the GNU Affero General Public License, version 3
 # (only), as published by the Free Software Foundation.
 #
 # 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 Affero General Public License
 # along with this program.  If not, see <http://www.gnu.org/licenses/>.
 #
 # This program is dual-licensed. If you wish to learn more about the
 # RhodeCode Enterprise Edition, including its added features, Support services,
 # and proprietary license terms, please see https://rhodecode.com/licenses/
 
 """
 Helper functions
 
 Consists of functions to typically be used within templates, but also
 available to Controllers. This module is available to both as 'h'.
 """
 import base64
 
 import os
 import random
 import hashlib
 import StringIO
 import textwrap
 import urllib
 import math
 import logging
 import re
 import time
 import string
 import hashlib
 import regex
 from collections import OrderedDict
 
 import pygments
 import itertools
 import fnmatch
 import bleach
 
 from pyramid import compat
 from datetime import datetime
 from functools import partial
 from pygments.formatters.html import HtmlFormatter
 from pygments.lexers import (
     get_lexer_by_name, get_lexer_for_filename, get_lexer_for_mimetype)
 
 from pyramid.threadlocal import get_current_request
 from tempita import looper
 from webhelpers2.html import literal, HTML, escape
 from webhelpers2.html._autolink import _auto_link_urls
 from webhelpers2.html.tools import (
     button_to, highlight, js_obfuscate, strip_links, strip_tags)
 
 from webhelpers2.text import (
     chop_at, collapse, convert_accented_entities,
     convert_misc_entities, lchop, plural, rchop, remove_formatting,
     replace_whitespace, urlify, truncate, wrap_paragraphs)
 from webhelpers2.date import time_ago_in_words
 
 from webhelpers2.html.tags import (
     _input, NotGiven, _make_safe_id_component as safeid,
     form as insecure_form,
     auto_discovery_link, checkbox, end_form, file,
     hidden, image, javascript_link, link_to, link_to_if, link_to_unless, ol,
     select as raw_select, stylesheet_link, submit, text, password, textarea,
     ul, radio, Options)
 
 from webhelpers2.number import format_byte_size
 
 from rhodecode.lib.action_parser import action_parser
 from rhodecode.lib.pagination import Page, RepoPage, SqlPage
 from rhodecode.lib.ext_json import json
 from rhodecode.lib.utils import repo_name_slug, get_custom_lexer
 from rhodecode.lib.utils2 import (
     str2bool, safe_unicode, safe_str,
     get_commit_safe, datetime_to_time, time_to_datetime, time_to_utcdatetime,
     AttributeDict, safe_int, md5, md5_safe, get_host_info)
 from rhodecode.lib.markup_renderer import MarkupRenderer, relative_links
 from rhodecode.lib.vcs.exceptions import CommitDoesNotExistError
 from rhodecode.lib.vcs.backends.base import BaseChangeset, EmptyCommit
 from rhodecode.lib.vcs.conf.settings import ARCHIVE_SPECS
 from rhodecode.lib.index.search_utils import get_matching_line_offsets
 from rhodecode.config.conf import DATE_FORMAT, DATETIME_FORMAT
 from rhodecode.model.changeset_status import ChangesetStatusModel
 from rhodecode.model.db import Permission, User, Repository, UserApiKeys, FileStore
 from rhodecode.model.repo_group import RepoGroupModel
 from rhodecode.model.settings import IssueTrackerSettingsModel
 
 
 log = logging.getLogger(__name__)
 
 
 DEFAULT_USER = User.DEFAULT_USER
 DEFAULT_USER_EMAIL = User.DEFAULT_USER_EMAIL
 
 
 def asset(path, ver=None, **kwargs):
     """
     Helper to generate a static asset file path for rhodecode assets
 
     eg. h.asset('images/image.png', ver='3923')
 
     :param path: path of asset
     :param ver: optional version query param to append as ?ver=
     """
     request = get_current_request()
     query = {}
     query.update(kwargs)
     if ver:
         query = {'ver': ver}
     return request.static_path(
         'rhodecode:public/{}'.format(path), _query=query)
 
 
 default_html_escape_table = {
     ord('&'): u'&amp;',
     ord('<'): u'&lt;',
     ord('>'): u'&gt;',
     ord('"'): u'&quot;',
     ord("'"): u'&#39;',
 }
 
 
 def html_escape(text, html_escape_table=default_html_escape_table):
     """Produce entities within text."""
     return text.translate(html_escape_table)
 
 
 def chop_at_smart(s, sub, inclusive=False, suffix_if_chopped=None):
     """
     Truncate string ``s`` at the first occurrence of ``sub``.
 
     If ``inclusive`` is true, truncate just after ``sub`` rather than at it.
     """
     suffix_if_chopped = suffix_if_chopped or ''
     pos = s.find(sub)
     if pos == -1:
         return s
 
     if inclusive:
         pos += len(sub)
 
     chopped = s[:pos]
     left = s[pos:].strip()
 
     if left and suffix_if_chopped:
         chopped += suffix_if_chopped
 
     return chopped
 
 
 def shorter(text, size=20, prefix=False):
     postfix = '...'
     if len(text) > size:
         if prefix:
             # shorten in front
             return postfix + text[-(size - len(postfix)):]
         else:
             return text[:size - len(postfix)] + postfix
     return text
 
 
 def reset(name, value=None, id=NotGiven, type="reset", **attrs):
     """
     Reset button
     """
     return _input(type, name, value, id, attrs)
 
 
 def select(name, selected_values, options, id=NotGiven, **attrs):
 
     if isinstance(options, (list, tuple)):
         options_iter = options
         # Handle old value,label lists ... where value also can be value,label lists
         options = Options()
         for opt in options_iter:
             if isinstance(opt, tuple) and len(opt) == 2:
                 value, label = opt
             elif isinstance(opt, basestring):
                 value = label = opt
             else:
                 raise ValueError('invalid select option type %r' % type(opt))
 
             if isinstance(value, (list, tuple)):
                 option_group = options.add_optgroup(label)
                 for opt2 in value:
                     if isinstance(opt2, tuple) and len(opt2) == 2:
                         group_value, group_label = opt2
                     elif isinstance(opt2, basestring):
                         group_value = group_label = opt2
                     else:
                         raise ValueError('invalid select option type %r' % type(opt2))
 
                     option_group.add_option(group_label, group_value)
             else:
                 options.add_option(label, value)
 
     return raw_select(name, selected_values, options, id=id, **attrs)
 
 
 def branding(name, length=40):
     return truncate(name, length, indicator="")
 
 
 def FID(raw_id, path):
     """
     Creates a unique ID for filenode based on it's hash of path and commit
     it's safe to use in urls
 
     :param raw_id:
     :param path:
     """
 
     return 'c-%s-%s' % (short_id(raw_id), md5_safe(path)[:12])
 
 
 class _GetError(object):
     """Get error from form_errors, and represent it as span wrapped error
     message
 
     :param field_name: field to fetch errors for
     :param form_errors: form errors dict
     """
 
     def __call__(self, field_name, form_errors):
         tmpl = """<span class="error_msg">%s</span>"""
         if form_errors and field_name in form_errors:
             return literal(tmpl % form_errors.get(field_name))
 
 
 get_error = _GetError()
 
 
 class _ToolTip(object):
 
     def __call__(self, tooltip_title, trim_at=50):
         """
         Special function just to wrap our text into nice formatted
         autowrapped text
 
         :param tooltip_title:
         """
         tooltip_title = escape(tooltip_title)
         tooltip_title = tooltip_title.replace('<', '&lt;').replace('>', '&gt;')
         return tooltip_title
 
 
 tooltip = _ToolTip()
 
 files_icon = u'<i class="file-breadcrumb-copy tooltip icon-clipboard clipboard-action" data-clipboard-text="{}" title="Copy file path"></i>'
 
 
 def files_breadcrumbs(repo_name, repo_type, commit_id, file_path, landing_ref_name=None, at_ref=None,
                       limit_items=False, linkify_last_item=False, hide_last_item=False,
                       copy_path_icon=True):
     if isinstance(file_path, str):
         file_path = safe_unicode(file_path)
 
     if at_ref:
         route_qry = {'at': at_ref}
         default_landing_ref = at_ref or landing_ref_name or commit_id
     else:
         route_qry = None
         default_landing_ref = commit_id
 
     # first segment is a `HOME` link to repo files root location
     root_name = literal(u'<i class="icon-home"></i>')
 
     url_segments = [
         link_to(
             root_name,
             repo_files_by_ref_url(
                 repo_name,
                 repo_type,
                 f_path=None,  # None here is a special case for SVN repos,
                               # that won't prefix with a ref
                 ref_name=default_landing_ref,
                 commit_id=commit_id,
                 query=route_qry
             )
         )]
 
     path_segments = file_path.split('/')
     last_cnt = len(path_segments) - 1
     for cnt, segment in enumerate(path_segments):
         if not segment:
             continue
         segment_html = escape(segment)
 
         last_item = cnt == last_cnt
 
         if last_item and hide_last_item:
             # iterate over and hide last element
             continue
 
         if last_item and linkify_last_item is False:
             # plain version
             url_segments.append(segment_html)
         else:
             url_segments.append(
                 link_to(
                     segment_html,
                     repo_files_by_ref_url(
                         repo_name,
                         repo_type,
                         f_path='/'.join(path_segments[:cnt + 1]),
                         ref_name=default_landing_ref,
                         commit_id=commit_id,
                         query=route_qry
                     ),
                 ))
 
     limited_url_segments = url_segments[:1] + ['...'] + url_segments[-5:]
     if limit_items and len(limited_url_segments) < len(url_segments):
         url_segments = limited_url_segments
 
     full_path = file_path
     if copy_path_icon:
         icon = files_icon.format(escape(full_path))
     else:
         icon = ''
 
     if file_path == '':
         return root_name
     else:
         return literal(' / '.join(url_segments) + icon)
 
 
 def files_url_data(request):
     matchdict = request.matchdict
 
     if 'f_path' not in matchdict:
         matchdict['f_path'] = ''
 
     if 'commit_id' not in matchdict:
         matchdict['commit_id'] = 'tip'
 
     return json.dumps(matchdict)
 
 
 def repo_files_by_ref_url(db_repo_name, db_repo_type, f_path, ref_name, commit_id, query=None, ):
     _is_svn = is_svn(db_repo_type)
     final_f_path = f_path
 
     if _is_svn:
         """
         For SVN the ref_name cannot be used as a commit_id, it needs to be prefixed with
         actually commit_id followed by the ref_name. This should be done only in case
         This is a initial landing url, without additional paths.
 
         like: /1000/tags/1.0.0/?at=tags/1.0.0
         """
 
         if ref_name and ref_name != 'tip':
             # NOTE(marcink): for svn the ref_name is actually the stored path, so we prefix it
             # for SVN we only do this magic prefix if it's root, .eg landing revision
             # of files link. If we are in the tree we don't need this since we traverse the url
             # that has everything stored
             if f_path in ['', '/']:
                 final_f_path = '/'.join([ref_name, f_path])
 
         # SVN always needs a commit_id explicitly, without a named REF
         default_commit_id = commit_id
     else:
         """
         For git and mercurial we construct a new URL using the names instead of commit_id
         like: /master/some_path?at=master
         """
         # We currently do not support branches with slashes
         if '/' in ref_name:
             default_commit_id = commit_id
         else:
             default_commit_id = ref_name
 
     # sometimes we pass f_path as None, to indicate explicit no prefix,
     # we translate it to string to not have None
     final_f_path = final_f_path or ''
 
     files_url = route_path(
         'repo_files',
         repo_name=db_repo_name,
         commit_id=default_commit_id,
         f_path=final_f_path,
         _query=query
     )
     return files_url
 
 
 def code_highlight(code, lexer, formatter, use_hl_filter=False):
     """
     Lex ``code`` with ``lexer`` and format it with the formatter ``formatter``.
 
     If ``outfile`` is given and a valid file object (an object
     with a ``write`` method), the result will be written to it, otherwise
     it is returned as a string.
     """
     if use_hl_filter:
         # add HL filter
         from rhodecode.lib.index import search_utils
         lexer.add_filter(search_utils.ElasticSearchHLFilter())
     return pygments.format(pygments.lex(code, lexer), formatter)
 
 
 class CodeHtmlFormatter(HtmlFormatter):
     """
     My code Html Formatter for source codes
     """
 
     def wrap(self, source, outfile):
         return self._wrap_div(self._wrap_pre(self._wrap_code(source)))
 
     def _wrap_code(self, source):
         for cnt, it in enumerate(source):
             i, t = it
             t = '<div id="L%s">%s</div>' % (cnt + 1, t)
             yield i, t
 
     def _wrap_tablelinenos(self, inner):
         dummyoutfile = StringIO.StringIO()
         lncount = 0
         for t, line in inner:
             if t:
                 lncount += 1
             dummyoutfile.write(line)
 
         fl = self.linenostart
         mw = len(str(lncount + fl - 1))
         sp = self.linenospecial
         st = self.linenostep
         la = self.lineanchors
         aln = self.anchorlinenos
         nocls = self.noclasses
         if sp:
             lines = []
 
             for i in range(fl, fl + lncount):
                 if i % st == 0:
                     if i % sp == 0:
                         if aln:
                             lines.append('<a href="#%s%d" class="special">%*d</a>' %
                                          (la, i, mw, i))
                         else:
                             lines.append('<span class="special">%*d</span>' % (mw, i))
                     else:
                         if aln:
                             lines.append('<a href="#%s%d">%*d</a>' % (la, i, mw, i))
                         else:
                             lines.append('%*d' % (mw, i))
                 else:
                     lines.append('')
             ls = '\n'.join(lines)
         else:
             lines = []
             for i in range(fl, fl + lncount):
                 if i % st == 0:
                     if aln:
                         lines.append('<a href="#%s%d">%*d</a>' % (la, i, mw, i))
                     else:
                         lines.append('%*d' % (mw, i))
                 else:
                     lines.append('')
             ls = '\n'.join(lines)
 
         # in case you wonder about the seemingly redundant <div> here: since the
         # content in the other cell also is wrapped in a div, some browsers in
         # some configurations seem to mess up the formatting...
         if nocls:
             yield 0, ('<table class="%stable">' % self.cssclass +
                       '<tr><td><div class="linenodiv" '
                       'style="background-color: #f0f0f0; padding-right: 10px">'
                       '<pre style="line-height: 125%">' +
                       ls + '</pre></div></td><td id="hlcode" class="code">')
         else:
             yield 0, ('<table class="%stable">' % self.cssclass +
                       '<tr><td class="linenos"><div class="linenodiv"><pre>' +
                       ls + '</pre></div></td><td id="hlcode" class="code">')
         yield 0, dummyoutfile.getvalue()
         yield 0, '</td></tr></table>'
 
 
 class SearchContentCodeHtmlFormatter(CodeHtmlFormatter):
     def __init__(self, **kw):
         # only show these line numbers if set
         self.only_lines = kw.pop('only_line_numbers', [])
         self.query_terms = kw.pop('query_terms', [])
         self.max_lines = kw.pop('max_lines', 5)
         self.line_context = kw.pop('line_context', 3)
         self.url = kw.pop('url', None)
 
         super(CodeHtmlFormatter, self).__init__(**kw)
 
     def _wrap_code(self, source):
         for cnt, it in enumerate(source):
             i, t = it
             t = '<pre>%s</pre>' % t
             yield i, t
 
     def _wrap_tablelinenos(self, inner):
         yield 0, '<table class="code-highlight %stable">' % self.cssclass
 
         last_shown_line_number = 0
         current_line_number = 1
 
         for t, line in inner:
             if not t:
                 yield t, line
                 continue
 
             if current_line_number in self.only_lines:
                 if last_shown_line_number + 1 != current_line_number:
                     yield 0, '<tr>'
                     yield 0, '<td class="line">...</td>'
                     yield 0, '<td id="hlcode" class="code"></td>'
                     yield 0, '</tr>'
 
                 yield 0, '<tr>'
                 if self.url:
                     yield 0, '<td class="line"><a href="%s#L%i">%i</a></td>' % (
                         self.url, current_line_number, current_line_number)
                 else:
                     yield 0, '<td class="line"><a href="">%i</a></td>' % (
                         current_line_number)
                 yield 0, '<td id="hlcode" class="code">' + line + '</td>'
                 yield 0, '</tr>'
 
                 last_shown_line_number = current_line_number
 
             current_line_number += 1
 
         yield 0, '</table>'
 
 
 def hsv_to_rgb(h, s, v):
     """ Convert hsv color values to rgb """
 
     if s == 0.0:
         return v, v, v
     i = int(h * 6.0)  # XXX assume int() truncates!
     f = (h * 6.0) - i
     p = v * (1.0 - s)
     q = v * (1.0 - s * f)
     t = v * (1.0 - s * (1.0 - f))
     i = i % 6
     if i == 0:
         return v, t, p
     if i == 1:
         return q, v, p
     if i == 2:
         return p, v, t
     if i == 3:
         return p, q, v
     if i == 4:
         return t, p, v
     if i == 5:
         return v, p, q
 
 
 def unique_color_generator(n=10000, saturation=0.10, lightness=0.95):
     """
     Generator for getting n of evenly distributed colors using
     hsv color and golden ratio. It always return same order of colors
 
     :param n: number of colors to generate
     :param saturation: saturation of returned colors
     :param lightness: lightness of returned colors
     :returns: RGB tuple
     """
 
     golden_ratio = 0.618033988749895
     h = 0.22717784590367374
 
     for _ in xrange(n):
         h += golden_ratio
         h %= 1
         HSV_tuple = [h, saturation, lightness]
         RGB_tuple = hsv_to_rgb(*HSV_tuple)
         yield map(lambda x: str(int(x * 256)), RGB_tuple)
 
 
 def color_hasher(n=10000, saturation=0.10, lightness=0.95):
     """
     Returns a function which when called with an argument returns a unique
     color for that argument, eg.
 
     :param n: number of colors to generate
     :param saturation: saturation of returned colors
     :param lightness: lightness of returned colors
     :returns: css RGB string
 
     >>> color_hash = color_hasher()
     >>> color_hash('hello')
     'rgb(34, 12, 59)'
     >>> color_hash('hello')
     'rgb(34, 12, 59)'
     >>> color_hash('other')
     'rgb(90, 224, 159)'
     """
 
     color_dict = {}
     cgenerator = unique_color_generator(
         saturation=saturation, lightness=lightness)
 
     def get_color_string(thing):
         if thing in color_dict:
             col = color_dict[thing]
         else:
             col = color_dict[thing] = cgenerator.next()
         return "rgb(%s)" % (', '.join(col))
 
     return get_color_string
 
 
 def get_lexer_safe(mimetype=None, filepath=None):
     """
     Tries to return a relevant pygments lexer using mimetype/filepath name,
     defaulting to plain text if none could be found
     """
     lexer = None
     try:
         if mimetype:
             lexer = get_lexer_for_mimetype(mimetype)
         if not lexer:
             lexer = get_lexer_for_filename(filepath)
     except pygments.util.ClassNotFound:
         pass
 
     if not lexer:
         lexer = get_lexer_by_name('text')
 
     return lexer
 
 
 def get_lexer_for_filenode(filenode):
     lexer = get_custom_lexer(filenode.extension) or filenode.lexer
     return lexer
 
 
 def pygmentize(filenode, **kwargs):
     """
     pygmentize function using pygments
 
     :param filenode:
     """
     lexer = get_lexer_for_filenode(filenode)
     return literal(code_highlight(filenode.content, lexer,
                                   CodeHtmlFormatter(**kwargs)))
 
 
 def is_following_repo(repo_name, user_id):
     from rhodecode.model.scm import ScmModel
     return ScmModel().is_following_repo(repo_name, user_id)
 
 
 class _Message(object):
     """A message returned by ``Flash.pop_messages()``.
 
     Converting the message to a string returns the message text. Instances
     also have the following attributes:
 
     * ``message``: the message text.
     * ``category``: the category specified when the message was created.
     """
 
     def __init__(self, category, message, sub_data=None):
         self.category = category
         self.message = message
         self.sub_data = sub_data or {}
 
     def __str__(self):
         return self.message
 
     __unicode__ = __str__
 
     def __html__(self):
         return escape(safe_unicode(self.message))
 
 
 class Flash(object):
     # List of allowed categories.  If None, allow any category.
     categories = ["warning", "notice", "error", "success"]
 
     # Default category if none is specified.
     default_category = "notice"
 
     def __init__(self, session_key="flash", categories=None,
                  default_category=None):
         """
         Instantiate a ``Flash`` object.
 
         ``session_key`` is the key to save the messages under in the user's
         session.
 
         ``categories`` is an optional list which overrides the default list
         of categories.
 
         ``default_category`` overrides the default category used for messages
         when none is specified.
         """
         self.session_key = session_key
         if categories is not None:
             self.categories = categories
         if default_category is not None:
             self.default_category = default_category
         if self.categories and self.default_category not in self.categories:
             raise ValueError(
                 "unrecognized default category %r" % (self.default_category,))
 
     def pop_messages(self, session=None, request=None):
         """
         Return all accumulated messages and delete them from the session.
 
         The return value is a list of ``Message`` objects.
         """
         messages = []
 
         if not session:
             if not request:
                 request = get_current_request()
             session = request.session
 
         # Pop the 'old' pylons flash messages. They are tuples of the form
         # (category, message)
         for cat, msg in session.pop(self.session_key, []):
             messages.append(_Message(cat, msg))
 
         # Pop the 'new' pyramid flash messages for each category as list
         # of strings.
         for cat in self.categories:
             for msg in session.pop_flash(queue=cat):
                 sub_data = {}
                 if hasattr(msg, 'rsplit'):
                     flash_data = msg.rsplit('|DELIM|', 1)
                     org_message = flash_data[0]
                     if len(flash_data) > 1:
                         sub_data = json.loads(flash_data[1])
                 else:
                     org_message = msg
 
                 messages.append(_Message(cat, org_message, sub_data=sub_data))
 
         # Map messages from the default queue to the 'notice' category.
         for msg in session.pop_flash():
             messages.append(_Message('notice', msg))
 
         session.save()
         return messages
 
     def json_alerts(self, session=None, request=None):
         payloads = []
         messages = flash.pop_messages(session=session, request=request) or []
         for message in messages:
             payloads.append({
                 'message': {
                     'message': u'{}'.format(message.message),
                     'level': message.category,
                     'force': True,
                     'subdata': message.sub_data
                 }
             })
         return json.dumps(payloads)
 
     def __call__(self, message, category=None, ignore_duplicate=True,
                  session=None, request=None):
 
         if not session:
             if not request:
                 request = get_current_request()
             session = request.session
 
         session.flash(
             message, queue=category, allow_duplicate=not ignore_duplicate)
 
 
 flash = Flash()
 
 #==============================================================================
 # SCM FILTERS available via h.
 #==============================================================================
 from rhodecode.lib.vcs.utils import author_name, author_email
 from rhodecode.lib.utils2 import age, age_from_seconds
 from rhodecode.model.db import User, ChangesetStatus
 
 
 email = author_email
 
 
 def capitalize(raw_text):
     return raw_text.capitalize()
 
 
 def short_id(long_id):
     return long_id[:12]
 
 
 def hide_credentials(url):
     from rhodecode.lib.utils2 import credentials_filter
     return credentials_filter(url)
 
 
 import pytz
 import tzlocal
 local_timezone = tzlocal.get_localzone()
 
 
 def get_timezone(datetime_iso, time_is_local=False):
     tzinfo = '+00:00'
 
     # detect if we have a timezone info, otherwise, add it
     if time_is_local and isinstance(datetime_iso, datetime) and not datetime_iso.tzinfo:
         force_timezone = os.environ.get('RC_TIMEZONE', '')
         if force_timezone:
             force_timezone = pytz.timezone(force_timezone)
         timezone = force_timezone or local_timezone
         offset = timezone.localize(datetime_iso).strftime('%z')
         tzinfo = '{}:{}'.format(offset[:-2], offset[-2:])
     return tzinfo
 
 
 def age_component(datetime_iso, value=None, time_is_local=False, tooltip=True):
     title = value or format_date(datetime_iso)
     tzinfo = get_timezone(datetime_iso, time_is_local=time_is_local)
 
     return literal(
         '<time class="timeago {cls}" title="{tt_title}" datetime="{dt}{tzinfo}">{title}</time>'.format(
             cls='tooltip' if tooltip else '',
             tt_title=('{title}{tzinfo}'.format(title=title, tzinfo=tzinfo)) if tooltip else '',
             title=title, dt=datetime_iso, tzinfo=tzinfo
         ))
 
 
 def _shorten_commit_id(commit_id, commit_len=None):
     if commit_len is None:
         request = get_current_request()
         commit_len = request.call_context.visual.show_sha_length
     return commit_id[:commit_len]
 
 
 def show_id(commit, show_idx=None, commit_len=None):
     """
     Configurable function that shows ID
     by default it's r123:fffeeefffeee
 
     :param commit: commit instance
     """
     if show_idx is None:
         request = get_current_request()
         show_idx = request.call_context.visual.show_revision_number
 
     raw_id = _shorten_commit_id(commit.raw_id, commit_len=commit_len)
     if show_idx:
         return 'r%s:%s' % (commit.idx, raw_id)
     else:
         return '%s' % (raw_id, )
 
 
 def format_date(date):
     """
     use a standardized formatting for dates used in RhodeCode
 
     :param date: date/datetime object
     :return: formatted date
     """
 
     if date:
         _fmt = "%a, %d %b %Y %H:%M:%S"
         return safe_unicode(date.strftime(_fmt))
 
     return u""
 
 
 class _RepoChecker(object):
 
     def __init__(self, backend_alias):
         self._backend_alias = backend_alias
 
     def __call__(self, repository):
         if hasattr(repository, 'alias'):
             _type = repository.alias
         elif hasattr(repository, 'repo_type'):
             _type = repository.repo_type
         else:
             _type = repository
         return _type == self._backend_alias
 
 
 is_git = _RepoChecker('git')
 is_hg = _RepoChecker('hg')
 is_svn = _RepoChecker('svn')
 
 
 def get_repo_type_by_name(repo_name):
     repo = Repository.get_by_repo_name(repo_name)
     if repo:
         return repo.repo_type
 
 
 def is_svn_without_proxy(repository):
     if is_svn(repository):
         from rhodecode.model.settings import VcsSettingsModel
         conf = VcsSettingsModel().get_ui_settings_as_config_obj()
         return not str2bool(conf.get('vcs_svn_proxy', 'http_requests_enabled'))
     return False
 
 
 def discover_user(author):
     """
     Tries to discover RhodeCode User based on the author string. Author string
     is typically `FirstName LastName <[e-mail]>`
     """
 
     # if author is already an instance use it for extraction
     if isinstance(author, User):
         return author
 
     # Valid email in the attribute passed, see if they're in the system
     _email = author_email(author)
     if _email != '':
         user = User.get_by_email(_email, case_insensitive=True, cache=True)
         if user is not None:
             return user
 
     # Maybe it's a username, we try to extract it and fetch by username ?
     _author = author_name(author)
     user = User.get_by_username(_author, case_insensitive=True, cache=True)
     if user is not None:
         return user
 
     return None
 
 
 def email_or_none(author):
     # extract email from the commit string
     _email = author_email(author)
 
     # If we have an email, use it, otherwise
     # see if it contains a username we can get an email from
     if _email != '':
         return _email
     else:
         user = User.get_by_username(
             author_name(author), case_insensitive=True, cache=True)
 
     if user is not None:
             return user.email
 
     # No valid email, not a valid user in the system, none!
     return None
 
 
 def link_to_user(author, length=0, **kwargs):
     user = discover_user(author)
     # user can be None, but if we have it already it means we can re-use it
     # in the person() function, so we save 1 intensive-query
     if user:
         author = user
 
     display_person = person(author, 'username_or_name_or_email')
     if length:
         display_person = shorter(display_person, length)
 
     if user and user.username != user.DEFAULT_USER:
         return link_to(
             escape(display_person),
             route_path('user_profile', username=user.username),
             **kwargs)
     else:
         return escape(display_person)
 
 
 def link_to_group(users_group_name, **kwargs):
     return link_to(
         escape(users_group_name),
         route_path('user_group_profile', user_group_name=users_group_name),
         **kwargs)
 
 
 def person(author, show_attr="username_and_name"):
     user = discover_user(author)
     if user:
         return getattr(user, show_attr)
     else:
         _author = author_name(author)
         _email = email(author)
         return _author or _email
 
 
 def author_string(email):
     if email:
         user = User.get_by_email(email, case_insensitive=True, cache=True)
         if user:
             if user.first_name or user.last_name:
                 return '%s %s &lt;%s&gt;' % (
                     user.first_name, user.last_name, email)
             else:
                 return email
         else:
             return email
     else:
         return None
 
 
 def person_by_id(id_, show_attr="username_and_name"):
     # attr to return from fetched user
     person_getter = lambda usr: getattr(usr, show_attr)
 
     #maybe it's an ID ?
     if str(id_).isdigit() or isinstance(id_, int):
         id_ = int(id_)
         user = User.get(id_)
         if user is not None:
             return person_getter(user)
     return id_
 
 
 def gravatar_with_user(request, author, show_disabled=False, tooltip=False):
     _render = request.get_partial_renderer('rhodecode:templates/base/base.mako')
     return _render('gravatar_with_user', author, show_disabled=show_disabled, tooltip=tooltip)
 
 
 tags_paterns = OrderedDict((
     ('lang', (re.compile(r'\[(lang|language)\ \=\&gt;\ *([a-zA-Z\-\/\#\+\.]*)\]'),
              '<div class="metatag" tag="lang">\\2</div>')),
 
     ('see', (re.compile(r'\[see\ \=\&gt;\ *([a-zA-Z0-9\/\=\?\&amp;\ \:\/\.\-]*)\]'),
             '<div class="metatag" tag="see">see: \\1 </div>')),
 
     ('url', (re.compile(r'\[url\ \=\&gt;\ \[([a-zA-Z0-9\ \.\-\_]+)\]\((http://|https://|/)(.*?)\)\]'),
             '<div class="metatag" tag="url"> <a href="\\2\\3">\\1</a> </div>')),
 
     ('license', (re.compile(r'\[license\ \=\&gt;\ *([a-zA-Z0-9\/\=\?\&amp;\ \:\/\.\-]*)\]'),
                 '<div class="metatag" tag="license"><a href="http:\/\/www.opensource.org/licenses/\\1">\\1</a></div>')),
 
     ('ref', (re.compile(r'\[(requires|recommends|conflicts|base)\ \=\&gt;\ *([a-zA-Z0-9\-\/]*)\]'),
             '<div class="metatag" tag="ref \\1">\\1: <a href="/\\2">\\2</a></div>')),
 
     ('state', (re.compile(r'\[(stable|featured|stale|dead|dev|deprecated)\]'),
               '<div class="metatag" tag="state \\1">\\1</div>')),
 
     # label in grey
     ('label', (re.compile(r'\[([a-z]+)\]'),
               '<div class="metatag" tag="label">\\1</div>')),
 
     # generic catch all in grey
     ('generic', (re.compile(r'\[([a-zA-Z0-9\.\-\_]+)\]'),
                 '<div class="metatag" tag="generic">\\1</div>')),
 ))
 
 
 def extract_metatags(value):
     """
     Extract supported meta-tags from given text value
     """
     tags = []
     if not value:
         return tags, ''
 
     for key, val in tags_paterns.items():
         pat, replace_html = val
         tags.extend([(key, x.group()) for x in pat.finditer(value)])
         value = pat.sub('', value)
 
     return tags, value
 
 
 def style_metatag(tag_type, value):
     """
     converts tags from value into html equivalent
     """
     if not value:
         return ''
 
     html_value = value
     tag_data = tags_paterns.get(tag_type)
     if tag_data:
         pat, replace_html = tag_data
         # convert to plain `unicode` instead of a markup tag to be used in
         # regex expressions. safe_unicode doesn't work here
         html_value = pat.sub(replace_html, unicode(value))
 
     return html_value
 
 
 def bool2icon(value, show_at_false=True):
     """
     Returns boolean value of a given value, represented as html element with
     classes that will represent icons
 
     :param value: given value to convert to html node
     """
 
     if value:  # does bool conversion
         return HTML.tag('i', class_="icon-true", title='True')
     else:  # not true as bool
         if show_at_false:
             return HTML.tag('i', class_="icon-false", title='False')
         return HTML.tag('i')
 
+
+def b64(inp):
+    return base64.b64encode(inp)
+
 #==============================================================================
 # PERMS
 #==============================================================================
 from rhodecode.lib.auth import (
     HasPermissionAny, HasPermissionAll,
     HasRepoPermissionAny, HasRepoPermissionAll, HasRepoGroupPermissionAll,
     HasRepoGroupPermissionAny, HasRepoPermissionAnyApi, get_csrf_token,
     csrf_token_key, AuthUser)
 
 
 #==============================================================================
 # GRAVATAR URL
 #==============================================================================
 class InitialsGravatar(object):
     def __init__(self, email_address, first_name, last_name, size=30,
                  background=None, text_color='#fff'):
         self.size = size
         self.first_name = first_name
         self.last_name = last_name
         self.email_address = email_address
         self.background = background or self.str2color(email_address)
         self.text_color = text_color
 
     def get_color_bank(self):
         """
         returns a predefined list of colors that gravatars can use.
         Those are randomized distinct colors that guarantee readability and
         uniqueness.
 
         generated with: http://phrogz.net/css/distinct-colors.html
         """
         return [
             '#bf3030', '#a67f53', '#00ff00', '#5989b3', '#392040', '#d90000',
             '#402910', '#204020', '#79baf2', '#a700b3', '#bf6060', '#7f5320',
             '#008000', '#003059', '#ee00ff', '#ff0000', '#8c4b00', '#007300',
             '#005fb3', '#de73e6', '#ff4040', '#ffaa00', '#3df255', '#203140',
             '#47004d', '#591616', '#664400', '#59b365', '#0d2133', '#83008c',
             '#592d2d', '#bf9f60', '#73e682', '#1d3f73', '#73006b', '#402020',
             '#b2862d', '#397341', '#597db3', '#e600d6', '#a60000', '#736039',
             '#00b318', '#79aaf2', '#330d30', '#ff8080', '#403010', '#16591f',
             '#002459', '#8c4688', '#e50000', '#ffbf40', '#00732e', '#102340',
             '#bf60ac', '#8c4646', '#cc8800', '#00a642', '#1d3473', '#b32d98',
             '#660e00', '#ffd580', '#80ffb2', '#7391e6', '#733967', '#d97b6c',
             '#8c5e00', '#59b389', '#3967e6', '#590047', '#73281d', '#665200',
             '#00e67a', '#2d50b3', '#8c2377', '#734139', '#b2982d', '#16593a',
             '#001859', '#ff00aa', '#a65e53', '#ffcc00', '#0d3321', '#2d3959',
             '#731d56', '#401610', '#4c3d00', '#468c6c', '#002ca6', '#d936a3',
             '#d94c36', '#403920', '#36d9a3', '#0d1733', '#592d4a', '#993626',
             '#cca300', '#00734d', '#46598c', '#8c005e', '#7f1100', '#8c7000',
             '#00a66f', '#7382e6', '#b32d74', '#d9896c', '#ffe680', '#1d7362',
             '#364cd9', '#73003d', '#d93a00', '#998a4d', '#59b3a1', '#5965b3',
             '#e5007a', '#73341d', '#665f00', '#00b38f', '#0018b3', '#59163a',
             '#b2502d', '#bfb960', '#00ffcc', '#23318c', '#a6537f', '#734939',
             '#b2a700', '#104036', '#3d3df2', '#402031', '#e56739', '#736f39',
             '#79f2ea', '#000059', '#401029', '#4c1400', '#ffee00', '#005953',
             '#101040', '#990052', '#402820', '#403d10', '#00ffee', '#0000d9',
             '#ff80c4', '#a66953', '#eeff00', '#00ccbe', '#8080ff', '#e673a1',
             '#a62c00', '#474d00', '#1a3331', '#46468c', '#733950', '#662900',
             '#858c23', '#238c85', '#0f0073', '#b20047', '#d9986c', '#becc00',
             '#396f73', '#281d73', '#ff0066', '#ff6600', '#dee673', '#59adb3',
             '#6559b3', '#590024', '#b2622d', '#98b32d', '#36ced9', '#332d59',
             '#40001a', '#733f1d', '#526600', '#005359', '#242040', '#bf6079',
             '#735039', '#cef23d', '#007780', '#5630bf', '#66001b', '#b24700',
             '#acbf60', '#1d6273', '#25008c', '#731d34', '#a67453', '#50592d',
             '#00ccff', '#6600ff', '#ff0044', '#4c1f00', '#8a994d', '#79daf2',
             '#a173e6', '#d93662', '#402310', '#aaff00', '#2d98b3', '#8c40ff',
             '#592d39', '#ff8c40', '#354020', '#103640', '#1a0040', '#331a20',
             '#331400', '#334d00', '#1d5673', '#583973', '#7f0022', '#4c3626',
             '#88cc00', '#36a3d9', '#3d0073', '#d9364c', '#33241a', '#698c23',
             '#5995b3', '#300059', '#e57382', '#7f3300', '#366600', '#00aaff',
             '#3a1659', '#733941', '#663600', '#74b32d', '#003c59', '#7f53a6',
             '#73000f', '#ff8800', '#baf279', '#79caf2', '#291040', '#a6293a',
             '#b2742d', '#587339', '#0077b3', '#632699', '#400009', '#d9a66c',
             '#294010', '#2d4a59', '#aa00ff', '#4c131b', '#b25f00', '#5ce600',
             '#267399', '#a336d9', '#990014', '#664e33', '#86bf60', '#0088ff',
             '#7700b3', '#593a16', '#073300', '#1d4b73', '#ac60bf', '#e59539',
             '#4f8c46', '#368dd9', '#5c0073'
         ]
 
     def rgb_to_hex_color(self, rgb_tuple):
         """
         Converts an rgb_tuple passed to an hex color.
 
         :param rgb_tuple: tuple with 3 ints represents rgb color space
         """
         return '#' + ("".join(map(chr, rgb_tuple)).encode('hex'))
 
     def email_to_int_list(self, email_str):
         """
         Get every byte of the hex digest value of email and turn it to integer.
         It's going to be always between 0-255
         """
         digest = md5_safe(email_str.lower())
         return [int(digest[i * 2:i * 2 + 2], 16) for i in range(16)]
 
     def pick_color_bank_index(self, email_str, color_bank):
         return self.email_to_int_list(email_str)[0] % len(color_bank)
 
     def str2color(self, email_str):
         """
         Tries to map in a stable algorithm an email to color
 
         :param email_str:
         """
         color_bank = self.get_color_bank()
         # pick position (module it's length so we always find it in the
         # bank even if it's smaller than 256 values
         pos = self.pick_color_bank_index(email_str, color_bank)
         return color_bank[pos]
 
     def normalize_email(self, email_address):
         import unicodedata
         # default host used to fill in the fake/missing email
         default_host = u'localhost'
 
         if not email_address:
             email_address = u'%s@%s' % (User.DEFAULT_USER, default_host)
 
         email_address = safe_unicode(email_address)
 
         if u'@' not in email_address:
             email_address = u'%s@%s' % (email_address, default_host)
 
         if email_address.endswith(u'@'):
             email_address = u'%s%s' % (email_address, default_host)
 
         email_address = unicodedata.normalize('NFKD', email_address)\
             .encode('ascii', 'ignore')
         return email_address
 
     def get_initials(self):
         """
         Returns 2 letter initials calculated based on the input.
         The algorithm picks first given email address, and takes first letter
         of part before @, and then the first letter of server name. In case
         the part before @ is in a format of `somestring.somestring2` it replaces
         the server letter with first letter of somestring2
 
         In case function was initialized with both first and lastname, this
         overrides the extraction from email by first letter of the first and
         last name. We add special logic to that functionality, In case Full name
         is compound, like Guido Von Rossum, we use last part of the last name
         (Von Rossum) picking `R`.
 
         Function also normalizes the non-ascii characters to they ascii
         representation, eg Ą => A
         """
         import unicodedata
         # replace non-ascii to ascii
         first_name = unicodedata.normalize(
             'NFKD', safe_unicode(self.first_name)).encode('ascii', 'ignore')
         last_name = unicodedata.normalize(
             'NFKD', safe_unicode(self.last_name)).encode('ascii', 'ignore')
 
         # do NFKD encoding, and also make sure email has proper format
         email_address = self.normalize_email(self.email_address)
 
         # first push the email initials
         prefix, server = email_address.split('@', 1)
 
         # check if prefix is maybe a 'first_name.last_name' syntax
         _dot_split = prefix.rsplit('.', 1)
         if len(_dot_split) == 2 and _dot_split[1]:
             initials = [_dot_split[0][0], _dot_split[1][0]]
         else:
             initials = [prefix[0], server[0]]
 
         # then try to replace either first_name or last_name
         fn_letter = (first_name or " ")[0].strip()
         ln_letter = (last_name.split(' ', 1)[-1] or " ")[0].strip()
 
         if fn_letter:
             initials[0] = fn_letter
 
         if ln_letter:
             initials[1] = ln_letter
 
         return ''.join(initials).upper()
 
     def get_img_data_by_type(self, font_family, img_type):
         default_user = """
         <svg xmlns="http://www.w3.org/2000/svg"
         version="1.1" x="0px" y="0px" width="{size}" height="{size}"
         viewBox="-15 -10 439.165 429.164"
 
         xml:space="preserve"
         style="background:{background};" >
 
         <path d="M204.583,216.671c50.664,0,91.74-48.075,
                  91.74-107.378c0-82.237-41.074-107.377-91.74-107.377
                  c-50.668,0-91.74,25.14-91.74,107.377C112.844,
                  168.596,153.916,216.671,
                  204.583,216.671z" fill="{text_color}"/>
         <path d="M407.164,374.717L360.88,
                  270.454c-2.117-4.771-5.836-8.728-10.465-11.138l-71.83-37.392
                  c-1.584-0.823-3.502-0.663-4.926,0.415c-20.316,
                  15.366-44.203,23.488-69.076,23.488c-24.877,
                  0-48.762-8.122-69.078-23.488
                  c-1.428-1.078-3.346-1.238-4.93-0.415L58.75,
                  259.316c-4.631,2.41-8.346,6.365-10.465,11.138L2.001,374.717
                  c-3.191,7.188-2.537,15.412,1.75,22.005c4.285,
                  6.592,11.537,10.526,19.4,10.526h362.861c7.863,0,15.117-3.936,
                  19.402-10.527 C409.699,390.129,
                  410.355,381.902,407.164,374.717z" fill="{text_color}"/>
         </svg>""".format(
             size=self.size,
             background='#979797',  # @grey4
             text_color=self.text_color,
             font_family=font_family)
 
         return {
             "default_user": default_user
         }[img_type]
 
     def get_img_data(self, svg_type=None):
         """
         generates the svg metadata for image
         """
         fonts = [
             '-apple-system',
              'BlinkMacSystemFont',
              'Segoe UI',
              'Roboto',
              'Oxygen-Sans',
              'Ubuntu',
              'Cantarell',
              'Helvetica Neue',
              'sans-serif'
         ]
         font_family = ','.join(fonts)
         if svg_type:
             return self.get_img_data_by_type(font_family, svg_type)
 
         initials = self.get_initials()
         img_data = """
         <svg xmlns="http://www.w3.org/2000/svg" pointer-events="none"
              width="{size}" height="{size}"
              style="width: 100%; height: 100%; background-color: {background}"
              viewBox="0 0 {size} {size}">
             <text text-anchor="middle" y="50%" x="50%" dy="0.35em"
                   pointer-events="auto" fill="{text_color}"
                   font-family="{font_family}"
                   style="font-weight: 400; font-size: {f_size}px;">{text}
             </text>
         </svg>""".format(
             size=self.size,
             f_size=self.size/2.05,  # scale the text inside the box nicely
             background=self.background,
             text_color=self.text_color,
             text=initials.upper(),
             font_family=font_family)
 
         return img_data
 
     def generate_svg(self, svg_type=None):
         img_data = self.get_img_data(svg_type)
         return "data:image/svg+xml;base64,%s" % base64.b64encode(img_data)
 
 
 def initials_gravatar(request, email_address, first_name, last_name, size=30, store_on_disk=False):
 
     svg_type = None
     if email_address == User.DEFAULT_USER_EMAIL:
         svg_type = 'default_user'
 
     klass = InitialsGravatar(email_address, first_name, last_name, size)
 
     if store_on_disk:
         from rhodecode.apps.file_store import utils as store_utils
         from rhodecode.apps.file_store.exceptions import FileNotAllowedException, \
             FileOverSizeException
         from rhodecode.model.db import Session
 
         image_key = md5_safe(email_address.lower()
                              + first_name.lower() + last_name.lower())
 
         storage = store_utils.get_file_storage(request.registry.settings)
         filename = '{}.svg'.format(image_key)
         subdir = 'gravatars'
         # since final name has a counter, we apply the 0
         uid = storage.apply_counter(0, store_utils.uid_filename(filename, randomized=False))
         store_uid = os.path.join(subdir, uid)
 
         db_entry = FileStore.get_by_store_uid(store_uid)
         if db_entry:
             return request.route_path('download_file', fid=store_uid)
 
         img_data = klass.get_img_data(svg_type=svg_type)
         img_file = store_utils.bytes_to_file_obj(img_data)
 
         try:
             store_uid, metadata = storage.save_file(
                 img_file, filename, directory=subdir,
                 extensions=['.svg'], randomized_name=False)
         except (FileNotAllowedException, FileOverSizeException):
             raise
 
         try:
             entry = FileStore.create(
                 file_uid=store_uid, filename=metadata["filename"],
                 file_hash=metadata["sha256"], file_size=metadata["size"],
                 file_display_name=filename,
                 file_description=u'user gravatar `{}`'.format(safe_unicode(filename)),
                 hidden=True, check_acl=False, user_id=1
             )
             Session().add(entry)
             Session().commit()
             log.debug('Stored upload in DB as %s', entry)
         except Exception:
             raise
 
         return request.route_path('download_file', fid=store_uid)
 
     else:
         return klass.generate_svg(svg_type=svg_type)
 
 
 def gravatar_external(request, gravatar_url_tmpl, email_address, size=30):
     return safe_str(gravatar_url_tmpl)\
         .replace('{email}', email_address) \
         .replace('{md5email}', md5_safe(email_address.lower())) \
         .replace('{netloc}', request.host) \
         .replace('{scheme}', request.scheme) \
         .replace('{size}', safe_str(size))
 
 
 def gravatar_url(email_address, size=30, request=None):
     request = request or get_current_request()
     _use_gravatar = request.call_context.visual.use_gravatar
 
     email_address = email_address or User.DEFAULT_USER_EMAIL
     if isinstance(email_address, unicode):
         # hashlib crashes on unicode items
         email_address = safe_str(email_address)
 
     # empty email or default user
     if not email_address or email_address == User.DEFAULT_USER_EMAIL:
         return initials_gravatar(request, User.DEFAULT_USER_EMAIL, '', '', size=size)
 
     if _use_gravatar:
         gravatar_url_tmpl = request.call_context.visual.gravatar_url \
                             or User.DEFAULT_GRAVATAR_URL
         return gravatar_external(request, gravatar_url_tmpl, email_address, size=size)
 
     else:
         return initials_gravatar(request, email_address, '', '', size=size)
 
 
 def breadcrumb_repo_link(repo):
     """
     Makes a breadcrumbs path link to repo
 
     ex::
         group >> subgroup >> repo
 
     :param repo: a Repository instance
     """
 
     path = [
         link_to(group.name, route_path('repo_group_home', repo_group_name=group.group_name),
                 title='last change:{}'.format(format_date(group.last_commit_change)))
         for group in repo.groups_with_parents
     ] + [
         link_to(repo.just_name, route_path('repo_summary', repo_name=repo.repo_name),
                 title='last change:{}'.format(format_date(repo.last_commit_change)))
     ]
 
     return literal(' &raquo; '.join(path))
 
 
 def breadcrumb_repo_group_link(repo_group):
     """
     Makes a breadcrumbs path link to repo
 
     ex::
         group >> subgroup
 
     :param repo_group: a Repository Group instance
     """
 
     path = [
         link_to(group.name,
                 route_path('repo_group_home', repo_group_name=group.group_name),
                 title='last change:{}'.format(format_date(group.last_commit_change)))
         for group in repo_group.parents
     ] + [
         link_to(repo_group.name,
                 route_path('repo_group_home', repo_group_name=repo_group.group_name),
                 title='last change:{}'.format(format_date(repo_group.last_commit_change)))
     ]
 
     return literal(' &raquo; '.join(path))
 
 
 def format_byte_size_binary(file_size):
     """
     Formats file/folder sizes to standard.
     """
     if file_size is None:
         file_size = 0
 
     formatted_size = format_byte_size(file_size, binary=True)
     return formatted_size
 
 
 def urlify_text(text_, safe=True, **href_attrs):
     """
     Extract urls from text and make html links out of them
     """
 
     url_pat = re.compile(r'''(http[s]?://(?:[a-zA-Z]|[0-9]|[$-_@#.&+]'''
                          '''|[!*\(\),]|(?:%[0-9a-fA-F][0-9a-fA-F]))+)''')
 
     def url_func(match_obj):
         url_full = match_obj.groups()[0]
         a_options = dict(href_attrs)
         a_options['href'] = url_full
         a_text = url_full
         return HTML.tag("a", a_text, **a_options)
 
     _new_text = url_pat.sub(url_func, text_)
 
     if safe:
         return literal(_new_text)
     return _new_text
 
 
 def urlify_commits(text_, repo_name):
     """
     Extract commit ids from text and make link from them
 
     :param text_:
     :param repo_name: repo name to build the URL with
     """
 
     url_pat = re.compile(r'(^|\s)([0-9a-fA-F]{12,40})($|\s)')
 
     def url_func(match_obj):
         commit_id = match_obj.groups()[1]
         pref = match_obj.groups()[0]
         suf = match_obj.groups()[2]
 
         tmpl = (
             '%(pref)s<a class="tooltip-hovercard %(cls)s" href="%(url)s" data-hovercard-alt="%(hovercard_alt)s" data-hovercard-url="%(hovercard_url)s">'
             '%(commit_id)s</a>%(suf)s'
         )
         return tmpl % {
             'pref': pref,
             'cls': 'revision-link',
             'url': route_url(
                 'repo_commit', repo_name=repo_name, commit_id=commit_id),
             'commit_id': commit_id,
             'suf': suf,
             'hovercard_alt': 'Commit: {}'.format(commit_id),
             'hovercard_url': route_url(
                 'hovercard_repo_commit', repo_name=repo_name, commit_id=commit_id)
         }
 
     new_text = url_pat.sub(url_func, text_)
 
     return new_text
 
 
 def _process_url_func(match_obj, repo_name, uid, entry,
                       return_raw_data=False, link_format='html'):
     pref = ''
     if match_obj.group().startswith(' '):
         pref = ' '
 
     issue_id = ''.join(match_obj.groups())
 
     if link_format == 'html':
         tmpl = (
             '%(pref)s<a class="tooltip %(cls)s" href="%(url)s" title="%(title)s">'
             '%(issue-prefix)s%(id-repr)s'
             '</a>')
     elif link_format == 'html+hovercard':
         tmpl = (
             '%(pref)s<a class="tooltip-hovercard %(cls)s" href="%(url)s" data-hovercard-url="%(hovercard_url)s">'
             '%(issue-prefix)s%(id-repr)s'
             '</a>')
     elif link_format in ['rst', 'rst+hovercard']:
         tmpl = '`%(issue-prefix)s%(id-repr)s <%(url)s>`_'
     elif link_format in ['markdown', 'markdown+hovercard']:
         tmpl = '[%(pref)s%(issue-prefix)s%(id-repr)s](%(url)s)'
     else:
         raise ValueError('Bad link_format:{}'.format(link_format))
 
     (repo_name_cleaned,
      parent_group_name) = RepoGroupModel()._get_group_name_and_parent(repo_name)
 
     # variables replacement
     named_vars = {
         'id': issue_id,
         'repo': repo_name,
         'repo_name': repo_name_cleaned,
         'group_name': parent_group_name,
         # set dummy keys so we always have them
         'hostname': '',
         'netloc': '',
         'scheme': ''
     }
 
     request = get_current_request()
     if request:
         # exposes, hostname, netloc, scheme
         host_data = get_host_info(request)
         named_vars.update(host_data)
 
     # named regex variables
     named_vars.update(match_obj.groupdict())
     _url = string.Template(entry['url']).safe_substitute(**named_vars)
     desc = string.Template(escape(entry['desc'])).safe_substitute(**named_vars)
     hovercard_url = string.Template(entry.get('hovercard_url', '')).safe_substitute(**named_vars)
 
     def quote_cleaner(input_str):
         """Remove quotes as it's HTML"""
         return input_str.replace('"', '')
 
     data = {
         'pref': pref,
         'cls': quote_cleaner('issue-tracker-link'),
         'url': quote_cleaner(_url),
         'id-repr': issue_id,
         'issue-prefix': entry['pref'],
         'serv': entry['url'],
         'title': bleach.clean(desc, strip=True),
         'hovercard_url': hovercard_url
     }
 
     if return_raw_data:
         return {
             'id': issue_id,
             'url': _url
         }
     return tmpl % data
 
 
 def get_active_pattern_entries(repo_name):
     repo = None
     if repo_name:
         # Retrieving repo_name to avoid invalid repo_name to explode on
         # IssueTrackerSettingsModel but still passing invalid name further down
         repo = Repository.get_by_repo_name(repo_name, cache=True)
 
     settings_model = IssueTrackerSettingsModel(repo=repo)
     active_entries = settings_model.get_settings(cache=True)
     return active_entries
 
 
 pr_pattern_re = regex.compile(r'(?:(?:^!)|(?: !))(\d+)')
 
 allowed_link_formats = [
     'html', 'rst', 'markdown', 'html+hovercard', 'rst+hovercard', 'markdown+hovercard']
 
 
 def process_patterns(text_string, repo_name, link_format='html', active_entries=None):
 
     if link_format not in allowed_link_formats:
         raise ValueError('Link format can be only one of:{} got {}'.format(
                          allowed_link_formats, link_format))
 
     if active_entries is None:
         log.debug('Fetch active issue tracker patterns for repo: %s', repo_name)
         active_entries = get_active_pattern_entries(repo_name)
 
     issues_data = []
     errors = []
     new_text = text_string
 
     log.debug('Got %s entries to process', len(active_entries))
     for uid, entry in active_entries.items():
         log.debug('found issue tracker entry with uid %s', uid)
 
         if not (entry['pat'] and entry['url']):
             log.debug('skipping due to missing data')
             continue
 
         log.debug('issue tracker entry: uid: `%s` PAT:%s URL:%s PREFIX:%s',
                   uid, entry['pat'], entry['url'], entry['pref'])
 
         if entry.get('pat_compiled'):
             pattern = entry['pat_compiled']
         else:
             try:
                 pattern = regex.compile(r'%s' % entry['pat'])
             except regex.error as e:
                 regex_err = ValueError('{}:{}'.format(entry['pat'], e))
                 log.exception('issue tracker pattern: `%s` failed to compile', regex_err)
                 errors.append(regex_err)
                 continue
 
         data_func = partial(
             _process_url_func, repo_name=repo_name, entry=entry, uid=uid,
             return_raw_data=True)
 
         for match_obj in pattern.finditer(text_string):
             issues_data.append(data_func(match_obj))
 
         url_func = partial(
             _process_url_func, repo_name=repo_name, entry=entry, uid=uid,
             link_format=link_format)
 
         new_text = pattern.sub(url_func, new_text)
         log.debug('processed prefix:uid `%s`', uid)
 
     # finally use global replace, eg !123 -> pr-link, those will not catch
     # if already similar pattern exists
     server_url = '${scheme}://${netloc}'
     pr_entry = {
         'pref': '!',
         'url': server_url + '/_admin/pull-requests/${id}',
         'desc': 'Pull Request !${id}',
         'hovercard_url': server_url + '/_hovercard/pull_request/${id}'
     }
     pr_url_func = partial(
         _process_url_func, repo_name=repo_name, entry=pr_entry, uid=None,
         link_format=link_format+'+hovercard')
     new_text = pr_pattern_re.sub(pr_url_func, new_text)
     log.debug('processed !pr pattern')
 
     return new_text, issues_data, errors
 
 
 def urlify_commit_message(commit_text, repository=None, active_pattern_entries=None,
                           issues_container=None, error_container=None):
     """
     Parses given text message and makes proper links.
     issues are linked to given issue-server, and rest is a commit link
     """
 
     def escaper(_text):
         return _text.replace('<', '&lt;').replace('>', '&gt;')
 
     new_text = escaper(commit_text)
 
     # extract http/https links and make them real urls
     new_text = urlify_text(new_text, safe=False)
 
     # urlify commits - extract commit ids and make link out of them, if we have
     # the scope of repository present.
     if repository:
         new_text = urlify_commits(new_text, repository)
 
     # process issue tracker patterns
     new_text, issues, errors = process_patterns(
         new_text, repository or '', active_entries=active_pattern_entries)
 
     if issues_container is not None:
         issues_container.extend(issues)
 
     if error_container is not None:
         error_container.extend(errors)
 
     return literal(new_text)
 
 
 def render_binary(repo_name, file_obj):
     """
     Choose how to render a binary file
     """
 
     # unicode
     filename = file_obj.name
 
     # images
     for ext in ['*.png', '*.jpeg', '*.jpg', '*.ico', '*.gif']:
         if fnmatch.fnmatch(filename, pat=ext):
             src = route_path(
                 'repo_file_raw', repo_name=repo_name,
                 commit_id=file_obj.commit.raw_id,
                 f_path=file_obj.path)
 
             return literal(
                 '<img class="rendered-binary" alt="rendered-image" src="{}">'.format(src))
 
 
 def renderer_from_filename(filename, exclude=None):
     """
     choose a renderer based on filename, this works only for text based files
     """
 
     # ipython
     for ext in ['*.ipynb']:
         if fnmatch.fnmatch(filename, pat=ext):
             return 'jupyter'
 
     is_markup = MarkupRenderer.renderer_from_filename(filename, exclude=exclude)
     if is_markup:
         return is_markup
     return None
 
 
 def render(source, renderer='rst', mentions=False, relative_urls=None,
            repo_name=None, active_pattern_entries=None, issues_container=None):
 
     def maybe_convert_relative_links(html_source):
         if relative_urls:
             return relative_links(html_source, relative_urls)
         return html_source
 
     if renderer == 'plain':
         return literal(
             MarkupRenderer.plain(source, leading_newline=False))
 
     elif renderer == 'rst':
         if repo_name:
             # process patterns on comments if we pass in repo name
             source, issues, errors = process_patterns(
                 source, repo_name, link_format='rst',
                 active_entries=active_pattern_entries)
             if issues_container is not None:
                 issues_container.extend(issues)
 
         return literal(
             '<div class="rst-block">%s</div>' %
             maybe_convert_relative_links(
                 MarkupRenderer.rst(source, mentions=mentions)))
 
     elif renderer == 'markdown':
         if repo_name:
             # process patterns on comments if we pass in repo name
             source, issues, errors = process_patterns(
                 source, repo_name, link_format='markdown',
                 active_entries=active_pattern_entries)
             if issues_container is not None:
                 issues_container.extend(issues)
 
         return literal(
             '<div class="markdown-block">%s</div>' %
             maybe_convert_relative_links(
                 MarkupRenderer.markdown(source, flavored=True,
                                         mentions=mentions)))
 
     elif renderer == 'jupyter':
         return literal(
             '<div class="ipynb">%s</div>' %
             maybe_convert_relative_links(
                 MarkupRenderer.jupyter(source)))
 
     # None means just show the file-source
     return None
 
 
 def commit_status(repo, commit_id):
     return ChangesetStatusModel().get_status(repo, commit_id)
 
 
 def commit_status_lbl(commit_status):
     return dict(ChangesetStatus.STATUSES).get(commit_status)
 
 
 def commit_time(repo_name, commit_id):
     repo = Repository.get_by_repo_name(repo_name)
     commit = repo.get_commit(commit_id=commit_id)
     return commit.date
 
 
 def get_permission_name(key):
     return dict(Permission.PERMS).get(key)
 
 
 def journal_filter_help(request):
     _ = request.translate
     from rhodecode.lib.audit_logger import ACTIONS
     actions = '\n'.join(textwrap.wrap(', '.join(sorted(ACTIONS.keys())), 80))
 
     return _(
         'Example filter terms:\n' +
         '     repository:vcs\n' +
         '     username:marcin\n' +
         '     username:(NOT marcin)\n' +
         '     action:*push*\n' +
         '     ip:127.0.0.1\n' +
         '     date:20120101\n' +
         '     date:[20120101100000 TO 20120102]\n' +
         '\n' +
         'Actions: {actions}\n' +
         '\n' +
         'Generate wildcards using \'*\' character:\n' +
         '     "repository:vcs*" - search everything starting with \'vcs\'\n' +
         '     "repository:*vcs*" - search for repository containing \'vcs\'\n' +
         '\n' +
         'Optional AND / OR operators in queries\n' +
         '     "repository:vcs OR repository:test"\n' +
         '     "username:test AND repository:test*"\n'
     ).format(actions=actions)
 
 
 def not_mapped_error(repo_name):
     from rhodecode.translation import _
     flash(_('%s repository is not mapped to db perhaps'
             ' it was created or renamed from the filesystem'
             ' please run the application again'
             ' in order to rescan repositories') % repo_name, category='error')
 
 
 def ip_range(ip_addr):
     from rhodecode.model.db import UserIpMap
     s, e = UserIpMap._get_ip_range(ip_addr)
     return '%s - %s' % (s, e)
 
 
 def form(url, method='post', needs_csrf_token=True, **attrs):
     """Wrapper around webhelpers.tags.form to prevent CSRF attacks."""
     if method.lower() != 'get' and needs_csrf_token:
         raise Exception(
             'Forms to POST/PUT/DELETE endpoints should have (in general) a ' +
             'CSRF token. If the endpoint does not require such token you can ' +
             'explicitly set the parameter needs_csrf_token to false.')
 
     return insecure_form(url, method=method, **attrs)
 
 
 def secure_form(form_url, method="POST", multipart=False, **attrs):
     """Start a form tag that points the action to an url. This
     form tag will also include the hidden field containing
     the auth token.
 
     The url options should be given either as a string, or as a
     ``url()`` function. The method for the form defaults to POST.
 
     Options:
 
     ``multipart``
         If set to True, the enctype is set to "multipart/form-data".
     ``method``
         The method to use when submitting the form, usually either
         "GET" or "POST". If "PUT", "DELETE", or another verb is used, a
         hidden input with name _method is added to simulate the verb
         over POST.
 
     """
 
     if 'request' in attrs:
         session = attrs['request'].session
         del attrs['request']
     else:
         raise ValueError(
             'Calling this form requires request= to be passed as argument')
 
     _form = insecure_form(form_url, method, multipart, **attrs)
     token = literal(
         '<input type="hidden" name="{}" value="{}">'.format(
             csrf_token_key, get_csrf_token(session)))
 
     return literal("%s\n%s" % (_form, token))
 
 
 def dropdownmenu(name, selected, options, enable_filter=False, **attrs):
     select_html = select(name, selected, options, **attrs)
 
     select2 = """
         <script>
             $(document).ready(function() {
                   $('#%s').select2({
                       containerCssClass: 'drop-menu %s',
                       dropdownCssClass: 'drop-menu-dropdown',
                       dropdownAutoWidth: true%s
                   });
             });
         </script>
     """
 
     filter_option = """,
                         minimumResultsForSearch: -1
     """
     input_id = attrs.get('id') or name
     extra_classes = ' '.join(attrs.pop('extra_classes', []))
     filter_enabled = "" if enable_filter else filter_option
     select_script = literal(select2 % (input_id, extra_classes, filter_enabled))
 
     return literal(select_html+select_script)
 
 
 def get_visual_attr(tmpl_context_var, attr_name):
     """
     A safe way to get a variable from visual variable of template context
 
     :param tmpl_context_var: instance of tmpl_context, usually present as `c`
     :param attr_name: name of the attribute we fetch from the c.visual
     """
     visual = getattr(tmpl_context_var, 'visual', None)
     if not visual:
         return
     else:
         return getattr(visual, attr_name, None)
 
 
 def get_last_path_part(file_node):
     if not file_node.path:
         return u'/'
 
     path = safe_unicode(file_node.path.split('/')[-1])
     return u'../' + path
 
 
 def route_url(*args, **kwargs):
     """
     Wrapper around pyramids `route_url` (fully qualified url) function.
     """
     req = get_current_request()
     return req.route_url(*args, **kwargs)
 
 
 def route_path(*args, **kwargs):
     """
     Wrapper around pyramids `route_path` function.
     """
     req = get_current_request()
     return req.route_path(*args, **kwargs)
 
 
 def route_path_or_none(*args, **kwargs):
     try:
         return route_path(*args, **kwargs)
     except KeyError:
         return None
 
 
 def current_route_path(request, **kw):
     new_args = request.GET.mixed()
     new_args.update(kw)
     return request.current_route_path(_query=new_args)
 
 
 def curl_api_example(method, args):
     args_json = json.dumps(OrderedDict([
         ('id', 1),
         ('auth_token', 'SECRET'),
         ('method', method),
         ('args', args)
     ]))
 
     return "curl {api_url} -X POST -H 'content-type:text/plain' --data-binary '{args_json}'".format(
         api_url=route_url('apiv2'),
         args_json=args_json
     )
 
 
 def api_call_example(method, args):
     """
     Generates an API call example via CURL
     """
     curl_call = curl_api_example(method, args)
 
     return literal(
         curl_call +
         "<br/><br/>SECRET can be found in <a href=\"{token_url}\">auth-tokens</a> page, "
         "and needs to be of `api calls` role."
         .format(token_url=route_url('my_account_auth_tokens')))
 
 
 def notification_description(notification, request):
     """
     Generate notification human readable description based on notification type
     """
     from rhodecode.model.notification import NotificationModel
     return NotificationModel().make_description(
         notification, translate=request.translate)
 
 
 def go_import_header(request, db_repo=None):
     """
     Creates a header for go-import functionality in Go Lang
     """
 
     if not db_repo:
         return
     if 'go-get' not in request.GET:
         return
 
     clone_url = db_repo.clone_url()
     prefix = re.split(r'^https?:\/\/', clone_url)[-1]
     # we have a repo and go-get flag,
     return literal('<meta name="go-import" content="{} {} {}">'.format(
         prefix, db_repo.repo_type, clone_url))
 
 
 def reviewer_as_json(*args, **kwargs):
     from rhodecode.apps.repository.utils import reviewer_as_json as _reviewer_as_json
     return _reviewer_as_json(*args, **kwargs)
 
 
 def get_repo_view_type(request):
     route_name = request.matched_route.name
     route_to_view_type = {
         'repo_changelog': 'commits',
         'repo_commits': 'commits',
         'repo_files': 'files',
         'repo_summary': 'summary',
         'repo_commit': 'commit'
     }
 
     return route_to_view_type.get(route_name)
 
 
 def is_active(menu_entry, selected):
     """
     Returns active class for selecting menus in templates
     <li class=${h.is_active('settings', current_active)}></li>
     """
     if not isinstance(menu_entry, list):
         menu_entry = [menu_entry]
 
     if selected in menu_entry:
         return "active"

rhodecode/model/changeset_status.py

@@ -1,397 +1,396 b''
 # -*- coding: utf-8 -*-
 
 # Copyright (C) 2010-2020 RhodeCode GmbH
 #
 # This program is free software: you can redistribute it and/or modify
 # it under the terms of the GNU Affero General Public License, version 3
 # (only), as published by the Free Software Foundation.
 #
 # 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 Affero General Public License
 # along with this program.  If not, see <http://www.gnu.org/licenses/>.
 #
 # This program is dual-licensed. If you wish to learn more about the
 # RhodeCode Enterprise Edition, including its added features, Support services,
 # and proprietary license terms, please see https://rhodecode.com/licenses/
 
 
 import itertools
 import logging
 import collections
 
 from rhodecode.model import BaseModel
 from rhodecode.model.db import (
-    ChangesetStatus, ChangesetComment, PullRequest, Session)
+    ChangesetStatus, ChangesetComment, PullRequest, PullRequestReviewers, Session)
 from rhodecode.lib.exceptions import StatusChangeOnClosedPullRequestError
 from rhodecode.lib.markup_renderer import (
     DEFAULT_COMMENTS_RENDERER, RstTemplateRenderer)
 
 log = logging.getLogger(__name__)
 
 
 class ChangesetStatusModel(BaseModel):
 
     cls = ChangesetStatus
 
     def __get_changeset_status(self, changeset_status):
         return self._get_instance(ChangesetStatus, changeset_status)
 
     def __get_pull_request(self, pull_request):
         return self._get_instance(PullRequest, pull_request)
 
     def _get_status_query(self, repo, revision, pull_request,
                           with_revisions=False):
         repo = self._get_repo(repo)
 
         q = ChangesetStatus.query()\
             .filter(ChangesetStatus.repo == repo)
         if not with_revisions:
             q = q.filter(ChangesetStatus.version == 0)
 
         if revision:
             q = q.filter(ChangesetStatus.revision == revision)
         elif pull_request:
             pull_request = self.__get_pull_request(pull_request)
             # TODO: johbo: Think about the impact of this join, there must
             # be a reason why ChangesetStatus and ChanagesetComment is linked
             # to the pull request. Might be that we want to do the same for
             # the pull_request_version_id.
             q = q.join(ChangesetComment).filter(
                 ChangesetStatus.pull_request == pull_request,
                 ChangesetComment.pull_request_version_id == None)
         else:
             raise Exception('Please specify revision or pull_request')
         q = q.order_by(ChangesetStatus.version.asc())
         return q
 
     def calculate_group_vote(self, group_id, group_statuses_by_reviewers,
                              trim_votes=True):
         """
         Calculate status based on given group members, and voting rule
 
 
         group1 - 4 members, 3 required for approval
             user1 - approved
             user2 - reject
             user3 - approved
             user4 - rejected
 
         final_state: rejected, reasons not at least 3 votes
 
 
         group1 - 4 members, 2 required for approval
             user1 - approved
             user2 - reject
             user3 - approved
             user4 - rejected
 
         final_state: approved, reasons got at least 2 approvals
 
         group1 - 4 members, ALL required for approval
             user1 - approved
             user2 - reject
             user3 - approved
             user4 - rejected
 
         final_state: rejected, reasons not all approvals
 
 
         group1 - 4 members, ALL required for approval
             user1 - approved
             user2 - approved
             user3 - approved
             user4 - approved
 
         final_state: approved, reason all approvals received
 
         group1 - 4 members, 5 required for approval
             (approval should be shorted to number of actual members)
 
             user1 - approved
             user2 - approved
             user3 - approved
             user4 - approved
 
         final_state: approved, reason all approvals received
 
         """
         group_vote_data = {}
         got_rule = False
         members = collections.OrderedDict()
         for review_obj, user, reasons, mandatory, statuses \
                 in group_statuses_by_reviewers:
 
             if not got_rule:
                 group_vote_data = review_obj.rule_user_group_data()
                 got_rule = bool(group_vote_data)
 
             members[user.user_id] = statuses
 
         if not group_vote_data:
             return []
 
         required_votes = group_vote_data['vote_rule']
         if required_votes == -1:
             # -1 means all required, so we replace it with how many people
             # are in the members
             required_votes = len(members)
 
         if trim_votes and required_votes > len(members):
             # we require more votes than we have members in the group
             # in this case we trim the required votes to the number of members
             required_votes = len(members)
 
         approvals = sum([
             1 for statuses in members.values()
             if statuses and
                statuses[0][1].status == ChangesetStatus.STATUS_APPROVED])
 
         calculated_votes = []
         # we have all votes from users, now check if we have enough votes
         # to fill other
         fill_in = ChangesetStatus.STATUS_UNDER_REVIEW
         if approvals >= required_votes:
             fill_in = ChangesetStatus.STATUS_APPROVED
 
         for member, statuses in members.items():
             if statuses:
                 ver, latest = statuses[0]
                 if fill_in == ChangesetStatus.STATUS_APPROVED:
                     calculated_votes.append(fill_in)
                 else:
                     calculated_votes.append(latest.status)
             else:
                 calculated_votes.append(fill_in)
 
         return calculated_votes
 
     def calculate_status(self, statuses_by_reviewers):
         """
         Given the approval statuses from reviewers, calculates final approval
         status. There can only be 3 results, all approved, all rejected. If
         there is no consensus the PR is under review.
 
         :param statuses_by_reviewers:
         """
 
         def group_rule(element):
             review_obj = element[0]
             rule_data = review_obj.rule_user_group_data()
             if rule_data and rule_data['id']:
                 return rule_data['id']
 
         voting_groups = itertools.groupby(
             sorted(statuses_by_reviewers, key=group_rule), group_rule)
 
         voting_by_groups = [(x, list(y)) for x, y in voting_groups]
 
         reviewers_number = len(statuses_by_reviewers)
         votes = collections.defaultdict(int)
         for group, group_statuses_by_reviewers in voting_by_groups:
             if group:
                 # calculate how the "group" voted
                 for vote_status in self.calculate_group_vote(
                         group, group_statuses_by_reviewers):
                     votes[vote_status] += 1
             else:
 
                 for review_obj, user, reasons, mandatory, statuses \
                         in group_statuses_by_reviewers:
                     # individual vote
                     if statuses:
                         ver, latest = statuses[0]
                         votes[latest.status] += 1
 
         approved_votes_count = votes[ChangesetStatus.STATUS_APPROVED]
         rejected_votes_count = votes[ChangesetStatus.STATUS_REJECTED]
 
         # TODO(marcink): with group voting, how does rejected work,
         # do we ever get rejected state ?
 
         if approved_votes_count and (approved_votes_count == reviewers_number):
             return ChangesetStatus.STATUS_APPROVED
 
         if rejected_votes_count and (rejected_votes_count == reviewers_number):
             return ChangesetStatus.STATUS_REJECTED
 
         return ChangesetStatus.STATUS_UNDER_REVIEW
 
     def get_statuses(self, repo, revision=None, pull_request=None,
                      with_revisions=False):
         q = self._get_status_query(repo, revision, pull_request,
                                    with_revisions)
         return q.all()
 
     def get_status(self, repo, revision=None, pull_request=None, as_str=True):
         """
         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:
         :param revision: 40char hash or None
         :param pull_request: pull_request reference
         :param as_str: return status as string not object
         """
         q = self._get_status_query(repo, revision, pull_request)
 
         # need to use first here since there can be multiple statuses
         # returned from pull_request
         status = q.first()
         if as_str:
             status = status.status if status else status
             st = status or ChangesetStatus.DEFAULT
             return str(st)
         return status
 
     def _render_auto_status_message(
             self, status, commit_id=None, pull_request=None):
         """
         render the message using DEFAULT_COMMENTS_RENDERER (RST renderer),
         so it's always looking the same disregarding on which default
         renderer system is using.
 
         :param status: status text to change into
         :param commit_id: the commit_id we change the status for
         :param pull_request: the pull request we change the status for
         """
 
         new_status = ChangesetStatus.get_status_lbl(status)
 
         params = {
             'new_status_label': new_status,
             'pull_request': pull_request,
             'commit_id': commit_id,
         }
         renderer = RstTemplateRenderer()
         return renderer.render('auto_status_change.mako', **params)
 
     def set_status(self, repo, status, user, comment=None, revision=None,
                    pull_request=None, dont_allow_on_closed_pull_request=False):
         """
         Creates new status for changeset or updates the old ones bumping their
         version, leaving the current status at
 
         :param repo:
         :param revision:
         :param status:
         :param user:
         :param comment:
         :param dont_allow_on_closed_pull_request: don't allow a status change
             if last status was for pull request and it's closed. We shouldn't
             mess around this manually
         """
         repo = self._get_repo(repo)
 
         q = ChangesetStatus.query()
 
         if revision:
             q = q.filter(ChangesetStatus.repo == repo)
             q = q.filter(ChangesetStatus.revision == revision)
         elif pull_request:
             pull_request = self.__get_pull_request(pull_request)
             q = q.filter(ChangesetStatus.repo == pull_request.source_repo)
             q = q.filter(ChangesetStatus.revision.in_(pull_request.revisions))
         cur_statuses = q.all()
 
         # if statuses exists and last is associated with a closed pull request
         # we need to check if we can allow this status change
         if (dont_allow_on_closed_pull_request and cur_statuses
             and getattr(cur_statuses[0].pull_request, 'status', '')
                 == PullRequest.STATUS_CLOSED):
             raise StatusChangeOnClosedPullRequestError(
                 'Changing status on closed pull request is not allowed'
             )
 
         # update all current statuses with older version
         if cur_statuses:
             for st in cur_statuses:
                 st.version += 1
                 Session().add(st)
             Session().flush()
 
         def _create_status(user, repo, status, comment, revision, pull_request):
             new_status = ChangesetStatus()
             new_status.author = self._get_user(user)
             new_status.repo = self._get_repo(repo)
             new_status.status = status
             new_status.comment = comment
             new_status.revision = revision
             new_status.pull_request = pull_request
             return new_status
 
         if not comment:
             from rhodecode.model.comment import CommentsModel
             comment = CommentsModel().create(
                 text=self._render_auto_status_message(
                     status, commit_id=revision, pull_request=pull_request),
                 repo=repo,
                 user=user,
                 pull_request=pull_request,
                 send_email=False, renderer=DEFAULT_COMMENTS_RENDERER
             )
 
         if revision:
             new_status = _create_status(
                 user=user, repo=repo, status=status, comment=comment,
                 revision=revision, pull_request=pull_request)
             Session().add(new_status)
             return new_status
         elif pull_request:
             # pull request can have more than one revision associated to it
             # we need to create new version for each one
             new_statuses = []
             repo = pull_request.source_repo
             for rev in pull_request.revisions:
                 new_status = _create_status(
                     user=user, repo=repo, status=status, comment=comment,
                     revision=rev, pull_request=pull_request)
                 new_statuses.append(new_status)
                 Session().add(new_status)
             return new_statuses
 
     def aggregate_votes_by_user(self, commit_statuses, reviewers_data):
 
         commit_statuses_map = collections.defaultdict(list)
         for st in commit_statuses:
             commit_statuses_map[st.author.username] += [st]
 
         reviewers = []
 
         def version(commit_status):
             return commit_status.version
 
         for obj in reviewers_data:
             if not obj.user:
                 continue
             statuses = commit_statuses_map.get(obj.user.username, None)
             if statuses:
                 status_groups = itertools.groupby(
                     sorted(statuses, key=version), version)
                 statuses = [(x, list(y)[0]) for x, y in status_groups]
 
             reviewers.append((obj, obj.user, obj.reasons, obj.mandatory, statuses))
 
         return reviewers
 
     def reviewers_statuses(self, pull_request):
         _commit_statuses = self.get_statuses(
             pull_request.source_repo,
             pull_request=pull_request,
             with_revisions=True)
+        reviewers = pull_request.get_pull_request_reviewers(
+            role=PullRequestReviewers.ROLE_REVIEWER)
+        return self.aggregate_votes_by_user(_commit_statuses, reviewers)
 
-        return self.aggregate_votes_by_user(_commit_statuses, pull_request.reviewers)
-
-    def calculated_review_status(self, pull_request, reviewers_statuses=None):
+    def calculated_review_status(self, pull_request):
         """
         calculate pull request status based on reviewers, it should be a list
         of two element lists.
-
-        :param reviewers_statuses:
         """
-        reviewers = reviewers_statuses or self.reviewers_statuses(pull_request)
+        reviewers = self.reviewers_statuses(pull_request)
         return self.calculate_status(reviewers)

rhodecode/model/comment.py

@@ -1,863 +1,862 b''
 # -*- coding: utf-8 -*-
 
 # Copyright (C) 2011-2020 RhodeCode GmbH
 #
 # This program is free software: you can redistribute it and/or modify
 # it under the terms of the GNU Affero General Public License, version 3
 # (only), as published by the Free Software Foundation.
 #
 # 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 Affero General Public License
 # along with this program.  If not, see <http://www.gnu.org/licenses/>.
 #
 # This program is dual-licensed. If you wish to learn more about the
 # RhodeCode Enterprise Edition, including its added features, Support services,
 # and proprietary license terms, please see https://rhodecode.com/licenses/
 
 """
 comments model for RhodeCode
 """
 import datetime
 
 import logging
 import traceback
 import collections
 
 from pyramid.threadlocal import get_current_registry, get_current_request
 from sqlalchemy.sql.expression import null
 from sqlalchemy.sql.functions import coalesce
 
 from rhodecode.lib import helpers as h, diffs, channelstream, hooks_utils
 from rhodecode.lib import audit_logger
 from rhodecode.lib.exceptions import CommentVersionMismatch
 from rhodecode.lib.utils2 import extract_mentioned_users, safe_str, safe_int
 from rhodecode.model import BaseModel
 from rhodecode.model.db import (
     ChangesetComment,
     User,
     Notification,
     PullRequest,
     AttributeDict,
     ChangesetCommentHistory,
 )
 from rhodecode.model.notification import NotificationModel
 from rhodecode.model.meta import Session
 from rhodecode.model.settings import VcsSettingsModel
 from rhodecode.model.notification import EmailNotificationModel
 from rhodecode.model.validation_schema.schemas import comment_schema
 
 
 log = logging.getLogger(__name__)
 
 
 class CommentsModel(BaseModel):
 
     cls = ChangesetComment
 
     DIFF_CONTEXT_BEFORE = 3
     DIFF_CONTEXT_AFTER = 3
 
     def __get_commit_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 _get_renderer(self, global_renderer='rst', request=None):
         request = request or get_current_request()
 
         try:
             global_renderer = request.call_context.visual.default_renderer
         except AttributeError:
             log.debug("Renderer not set, falling back "
                       "to default renderer '%s'", global_renderer)
         except Exception:
             log.error(traceback.format_exc())
         return global_renderer
 
     def aggregate_comments(self, comments, versions, show_version, inline=False):
         # group by versions, and count until, and display objects
 
         comment_groups = collections.defaultdict(list)
         [comment_groups[_co.pull_request_version_id].append(_co) for _co in comments]
 
         def yield_comments(pos):
             for co in comment_groups[pos]:
                 yield co
 
         comment_versions = collections.defaultdict(
             lambda: collections.defaultdict(list))
         prev_prvid = -1
         # fake last entry with None, to aggregate on "latest" version which
         # doesn't have an pull_request_version_id
         for ver in versions + [AttributeDict({'pull_request_version_id': None})]:
             prvid = ver.pull_request_version_id
             if prev_prvid == -1:
                 prev_prvid = prvid
 
             for co in yield_comments(prvid):
                 comment_versions[prvid]['at'].append(co)
 
             # save until
             current = comment_versions[prvid]['at']
             prev_until = comment_versions[prev_prvid]['until']
             cur_until = prev_until + current
             comment_versions[prvid]['until'].extend(cur_until)
 
             # save outdated
             if inline:
                 outdated = [x for x in cur_until
                             if x.outdated_at_version(show_version)]
             else:
                 outdated = [x for x in cur_until
                             if x.older_than_version(show_version)]
             display = [x for x in cur_until if x not in outdated]
 
             comment_versions[prvid]['outdated'] = outdated
             comment_versions[prvid]['display'] = display
 
             prev_prvid = prvid
 
         return comment_versions
 
     def get_repository_comments(self, repo, comment_type=None, user=None, commit_id=None):
         qry = Session().query(ChangesetComment) \
             .filter(ChangesetComment.repo == repo)
 
         if comment_type and comment_type in ChangesetComment.COMMENT_TYPES:
             qry = qry.filter(ChangesetComment.comment_type == comment_type)
 
         if user:
             user = self._get_user(user)
             if user:
                 qry = qry.filter(ChangesetComment.user_id == user.user_id)
 
         if commit_id:
             qry = qry.filter(ChangesetComment.revision == commit_id)
 
         qry = qry.order_by(ChangesetComment.created_on)
         return qry.all()
 
     def get_repository_unresolved_todos(self, repo):
         todos = Session().query(ChangesetComment) \
             .filter(ChangesetComment.repo == repo) \
             .filter(ChangesetComment.resolved_by == None) \
             .filter(ChangesetComment.comment_type
                     == ChangesetComment.COMMENT_TYPE_TODO)
         todos = todos.all()
 
         return todos
 
     def get_pull_request_unresolved_todos(self, pull_request, show_outdated=True):
 
         todos = Session().query(ChangesetComment) \
             .filter(ChangesetComment.pull_request == pull_request) \
             .filter(ChangesetComment.resolved_by == None) \
             .filter(ChangesetComment.comment_type
                     == ChangesetComment.COMMENT_TYPE_TODO)
 
         if not show_outdated:
             todos = todos.filter(
                 coalesce(ChangesetComment.display_state, '') !=
                 ChangesetComment.COMMENT_OUTDATED)
 
         todos = todos.all()
 
         return todos
 
     def get_pull_request_resolved_todos(self, pull_request, show_outdated=True):
 
         todos = Session().query(ChangesetComment) \
             .filter(ChangesetComment.pull_request == pull_request) \
             .filter(ChangesetComment.resolved_by != None) \
             .filter(ChangesetComment.comment_type
                     == ChangesetComment.COMMENT_TYPE_TODO)
 
         if not show_outdated:
             todos = todos.filter(
                 coalesce(ChangesetComment.display_state, '') !=
                 ChangesetComment.COMMENT_OUTDATED)
 
         todos = todos.all()
 
         return todos
 
     def get_commit_unresolved_todos(self, commit_id, show_outdated=True):
 
         todos = Session().query(ChangesetComment) \
             .filter(ChangesetComment.revision == commit_id) \
             .filter(ChangesetComment.resolved_by == None) \
             .filter(ChangesetComment.comment_type
                     == ChangesetComment.COMMENT_TYPE_TODO)
 
         if not show_outdated:
             todos = todos.filter(
                 coalesce(ChangesetComment.display_state, '') !=
                 ChangesetComment.COMMENT_OUTDATED)
 
         todos = todos.all()
 
         return todos
 
     def get_commit_resolved_todos(self, commit_id, show_outdated=True):
 
         todos = Session().query(ChangesetComment) \
             .filter(ChangesetComment.revision == commit_id) \
             .filter(ChangesetComment.resolved_by != None) \
             .filter(ChangesetComment.comment_type
                     == ChangesetComment.COMMENT_TYPE_TODO)
 
         if not show_outdated:
             todos = todos.filter(
                 coalesce(ChangesetComment.display_state, '') !=
                 ChangesetComment.COMMENT_OUTDATED)
 
         todos = todos.all()
 
         return todos
 
     def get_commit_inline_comments(self, commit_id):
         inline_comments = Session().query(ChangesetComment) \
             .filter(ChangesetComment.line_no != None) \
             .filter(ChangesetComment.f_path != None) \
             .filter(ChangesetComment.revision == commit_id)
         inline_comments = inline_comments.all()
         return inline_comments
 
     def _log_audit_action(self, action, action_data, auth_user, comment):
         audit_logger.store(
             action=action,
             action_data=action_data,
             user=auth_user,
             repo=comment.repo)
 
     def create(self, text, repo, user, commit_id=None, pull_request=None,
                f_path=None, line_no=None, status_change=None,
                status_change_type=None, comment_type=None,
                resolves_comment_id=None, closing_pr=False, send_email=True,
                renderer=None, auth_user=None, extra_recipients=None):
         """
         Creates new comment for commit or pull request.
         IF status_change is not none this comment is associated with a
         status change of commit or commit associated with pull request
 
         :param text:
         :param repo:
         :param user:
         :param commit_id:
         :param pull_request:
         :param f_path:
         :param line_no:
         :param status_change: Label for status change
         :param comment_type: Type of comment
         :param resolves_comment_id: id of comment which this one will resolve
         :param status_change_type: type of status change
         :param closing_pr:
         :param send_email:
         :param renderer: pick renderer for this comment
         :param auth_user: current authenticated user calling this method
         :param extra_recipients: list of extra users to be added to recipients
         """
 
         if not text:
             log.warning('Missing text for comment, skipping...')
             return
         request = get_current_request()
         _ = request.translate
 
         if not renderer:
             renderer = self._get_renderer(request=request)
 
         repo = self._get_repo(repo)
         user = self._get_user(user)
         auth_user = auth_user or user
 
         schema = comment_schema.CommentSchema()
         validated_kwargs = schema.deserialize(dict(
             comment_body=text,
             comment_type=comment_type,
             comment_file=f_path,
             comment_line=line_no,
             renderer_type=renderer,
             status_change=status_change_type,
             resolves_comment_id=resolves_comment_id,
             repo=repo.repo_id,
             user=user.user_id,
         ))
 
         comment = ChangesetComment()
         comment.renderer = validated_kwargs['renderer_type']
         comment.text = validated_kwargs['comment_body']
         comment.f_path = validated_kwargs['comment_file']
         comment.line_no = validated_kwargs['comment_line']
         comment.comment_type = validated_kwargs['comment_type']
 
         comment.repo = repo
         comment.author = user
         resolved_comment = self.__get_commit_comment(
             validated_kwargs['resolves_comment_id'])
         # check if the comment actually belongs to this PR
         if resolved_comment and resolved_comment.pull_request and \
                 resolved_comment.pull_request != pull_request:
             log.warning('Comment tried to resolved unrelated todo comment: %s',
                         resolved_comment)
             # comment not bound to this pull request, forbid
             resolved_comment = None
 
         elif resolved_comment and resolved_comment.repo and \
                 resolved_comment.repo != repo:
             log.warning('Comment tried to resolved unrelated todo comment: %s',
                         resolved_comment)
             # comment not bound to this repo, forbid
             resolved_comment = None
 
         comment.resolved_comment = resolved_comment
 
         pull_request_id = pull_request
 
         commit_obj = None
         pull_request_obj = None
 
         if commit_id:
             notification_type = EmailNotificationModel.TYPE_COMMIT_COMMENT
             # do a lookup, so we don't pass something bad here
             commit_obj = repo.scm_instance().get_commit(commit_id=commit_id)
             comment.revision = commit_obj.raw_id
 
         elif pull_request_id:
             notification_type = EmailNotificationModel.TYPE_PULL_REQUEST_COMMENT
             pull_request_obj = self.__get_pull_request(pull_request_id)
             comment.pull_request = pull_request_obj
         else:
             raise Exception('Please specify commit or pull_request_id')
 
         Session().add(comment)
         Session().flush()
         kwargs = {
             'user': user,
             'renderer_type': renderer,
             'repo_name': repo.repo_name,
             'status_change': status_change,
             'status_change_type': status_change_type,
             'comment_body': text,
             'comment_file': f_path,
             'comment_line': line_no,
             'comment_type': comment_type or 'note',
             'comment_id': comment.comment_id
         }
 
         if commit_obj:
             recipients = ChangesetComment.get_users(
                 revision=commit_obj.raw_id)
             # add commit author if it's in RhodeCode system
             cs_author = User.get_from_cs_author(commit_obj.author)
             if not cs_author:
                 # use repo owner if we cannot extract the author correctly
                 cs_author = repo.user
             recipients += [cs_author]
 
             commit_comment_url = self.get_url(comment, request=request)
             commit_comment_reply_url = self.get_url(
                 comment, request=request,
                 anchor='comment-{}/?/ReplyToComment'.format(comment.comment_id))
 
             target_repo_url = h.link_to(
                 repo.repo_name,
                 h.route_url('repo_summary', repo_name=repo.repo_name))
 
             commit_url = h.route_url('repo_commit', repo_name=repo.repo_name,
                                      commit_id=commit_id)
 
             # commit specifics
             kwargs.update({
                 'commit': commit_obj,
                 'commit_message': commit_obj.message,
                 'commit_target_repo_url': target_repo_url,
                 'commit_comment_url': commit_comment_url,
                 'commit_comment_reply_url': commit_comment_reply_url,
                 'commit_url': commit_url,
                 'thread_ids': [commit_url, commit_comment_url],
             })
 
         elif pull_request_obj:
             # get the current participants of this pull request
             recipients = ChangesetComment.get_users(
                 pull_request_id=pull_request_obj.pull_request_id)
             # add pull request author
             recipients += [pull_request_obj.author]
 
             # add the reviewers to notification
             recipients += [x.user for x in pull_request_obj.reviewers]
 
             pr_target_repo = pull_request_obj.target_repo
             pr_source_repo = pull_request_obj.source_repo
 
             pr_comment_url = self.get_url(comment, request=request)
             pr_comment_reply_url = self.get_url(
                 comment, request=request,
                 anchor='comment-{}/?/ReplyToComment'.format(comment.comment_id))
 
             pr_url = h.route_url(
                 'pullrequest_show',
                 repo_name=pr_target_repo.repo_name,
                 pull_request_id=pull_request_obj.pull_request_id, )
 
             # set some variables for email notification
             pr_target_repo_url = h.route_url(
                 'repo_summary', repo_name=pr_target_repo.repo_name)
 
             pr_source_repo_url = h.route_url(
                 'repo_summary', repo_name=pr_source_repo.repo_name)
 
             # pull request specifics
             kwargs.update({
                 'pull_request': pull_request_obj,
                 'pr_id': pull_request_obj.pull_request_id,
                 'pull_request_url': pr_url,
                 'pull_request_target_repo': pr_target_repo,
                 'pull_request_target_repo_url': pr_target_repo_url,
                 'pull_request_source_repo': pr_source_repo,
                 'pull_request_source_repo_url': pr_source_repo_url,
                 'pr_comment_url': pr_comment_url,
                 'pr_comment_reply_url': pr_comment_reply_url,
                 'pr_closing': closing_pr,
                 'thread_ids': [pr_url, pr_comment_url],
             })
 
-        recipients += [self._get_user(u) for u in (extra_recipients or [])]
-
         if send_email:
+            recipients += [self._get_user(u) for u in (extra_recipients or [])]
             # pre-generate the subject for notification itself
             (subject, _e, body_plaintext) = EmailNotificationModel().render_email(
                 notification_type, **kwargs)
 
             mention_recipients = set(
                 self._extract_mentions(text)).difference(recipients)
 
             # create notification objects, and emails
             NotificationModel().create(
                 created_by=user,
                 notification_subject=subject,
                 notification_body=body_plaintext,
                 notification_type=notification_type,
                 recipients=recipients,
                 mention_recipients=mention_recipients,
                 email_kwargs=kwargs,
             )
 
         Session().flush()
         if comment.pull_request:
             action = 'repo.pull_request.comment.create'
         else:
             action = 'repo.commit.comment.create'
 
         comment_id = comment.comment_id
         comment_data = comment.get_api_data()
 
         self._log_audit_action(
             action, {'data': comment_data}, auth_user, comment)
 
         channel = None
         if commit_obj:
             repo_name = repo.repo_name
             channel = u'/repo${}$/commit/{}'.format(
                 repo_name,
                 commit_obj.raw_id
             )
         elif pull_request_obj:
             repo_name = pr_target_repo.repo_name
             channel = u'/repo${}$/pr/{}'.format(
                 repo_name,
                 pull_request_obj.pull_request_id
             )
 
         if channel:
             username = user.username
             message = '<strong>{}</strong> {} #{}, {}'
             message = message.format(
                 username,
                 _('posted a new comment'),
                 comment_id,
                 _('Refresh the page to see new comments.'))
 
             message_obj = {
                 'message': message,
                 'level': 'success',
                 'topic': '/notifications'
             }
 
             channelstream.post_message(
                 channel, message_obj, user.username,
                 registry=get_current_registry())
 
             message_obj = {
                 'message': None,
                 'user': username,
                 'comment_id': comment_id,
                 'topic': '/comment'
             }
             channelstream.post_message(
                 channel, message_obj, user.username,
                 registry=get_current_registry())
 
         return comment
 
     def edit(self, comment_id, text, auth_user, version):
         """
         Change existing comment for commit or pull request.
 
         :param comment_id:
         :param text:
         :param auth_user: current authenticated user calling this method
         :param version: last comment version
         """
         if not text:
             log.warning('Missing text for comment, skipping...')
             return
 
         comment = ChangesetComment.get(comment_id)
         old_comment_text = comment.text
         comment.text = text
         comment.modified_at = datetime.datetime.now()
         version = safe_int(version)
 
         # NOTE(marcink): this returns initial comment + edits, so v2 from ui
         # would return 3 here
         comment_version = ChangesetCommentHistory.get_version(comment_id)
 
         if isinstance(version, (int, long)) and (comment_version - version) != 1:
             log.warning(
                 'Version mismatch comment_version {} submitted {}, skipping'.format(
                     comment_version-1,  # -1 since note above
                     version
                 )
             )
             raise CommentVersionMismatch()
 
         comment_history = ChangesetCommentHistory()
         comment_history.comment_id = comment_id
         comment_history.version = comment_version
         comment_history.created_by_user_id = auth_user.user_id
         comment_history.text = old_comment_text
         # TODO add email notification
         Session().add(comment_history)
         Session().add(comment)
         Session().flush()
 
         if comment.pull_request:
             action = 'repo.pull_request.comment.edit'
         else:
             action = 'repo.commit.comment.edit'
 
         comment_data = comment.get_api_data()
         comment_data['old_comment_text'] = old_comment_text
         self._log_audit_action(
             action, {'data': comment_data}, auth_user, comment)
 
         return comment_history
 
     def delete(self, comment, auth_user):
         """
         Deletes given comment
         """
         comment = self.__get_commit_comment(comment)
         old_data = comment.get_api_data()
         Session().delete(comment)
 
         if comment.pull_request:
             action = 'repo.pull_request.comment.delete'
         else:
             action = 'repo.commit.comment.delete'
 
         self._log_audit_action(
             action, {'old_data': old_data}, auth_user, comment)
 
         return comment
 
     def get_all_comments(self, repo_id, revision=None, pull_request=None):
         q = ChangesetComment.query()\
                 .filter(ChangesetComment.repo_id == repo_id)
         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 commit or pull_request')
         q = q.order_by(ChangesetComment.created_on)
         return q.all()
 
     def get_url(self, comment, request=None, permalink=False, anchor=None):
         if not request:
             request = get_current_request()
 
         comment = self.__get_commit_comment(comment)
         if anchor is None:
             anchor = 'comment-{}'.format(comment.comment_id)
 
         if comment.pull_request:
             pull_request = comment.pull_request
             if permalink:
                 return request.route_url(
                     'pull_requests_global',
                     pull_request_id=pull_request.pull_request_id,
                     _anchor=anchor)
             else:
                 return request.route_url(
                     'pullrequest_show',
                     repo_name=safe_str(pull_request.target_repo.repo_name),
                     pull_request_id=pull_request.pull_request_id,
                     _anchor=anchor)
 
         else:
             repo = comment.repo
             commit_id = comment.revision
 
             if permalink:
                 return request.route_url(
                     'repo_commit', repo_name=safe_str(repo.repo_id),
                     commit_id=commit_id,
                     _anchor=anchor)
 
             else:
                 return request.route_url(
                     'repo_commit', repo_name=safe_str(repo.repo_name),
                     commit_id=commit_id,
                     _anchor=anchor)
 
     def get_comments(self, repo_id, revision=None, pull_request=None):
         """
         Gets main comments based on revision or pull_request_id
 
         :param repo_id:
         :param revision:
         :param 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 commit or pull_request')
         q = q.order_by(ChangesetComment.created_on)
         return q.all()
 
     def get_inline_comments(self, repo_id, revision=None, pull_request=None):
         q = self._get_inline_comments_query(repo_id, revision, pull_request)
         return self._group_comments_by_path_and_line_number(q)
 
     def get_inline_comments_as_list(self, inline_comments, skip_outdated=True,
                                     version=None):
         inline_comms = []
         for fname, per_line_comments in inline_comments.iteritems():
             for lno, comments in per_line_comments.iteritems():
                 for comm in comments:
                     if not comm.outdated_at_version(version) and skip_outdated:
                         inline_comms.append(comm)
 
         return inline_comms
 
     def get_outdated_comments(self, repo_id, pull_request):
         # TODO: johbo: Remove `repo_id`, it is not needed to find the comments
         # of a pull request.
         q = self._all_inline_comments_of_pull_request(pull_request)
         q = q.filter(
             ChangesetComment.display_state ==
             ChangesetComment.COMMENT_OUTDATED
         ).order_by(ChangesetComment.comment_id.asc())
 
         return self._group_comments_by_path_and_line_number(q)
 
     def _get_inline_comments_query(self, repo_id, revision, pull_request):
         # TODO: johbo: Split this into two methods: One for PR and one for
         # commit.
         if revision:
             q = Session().query(ChangesetComment).filter(
                 ChangesetComment.repo_id == repo_id,
                 ChangesetComment.line_no != null(),
                 ChangesetComment.f_path != null(),
                 ChangesetComment.revision == revision)
 
         elif pull_request:
             pull_request = self.__get_pull_request(pull_request)
             if not CommentsModel.use_outdated_comments(pull_request):
                 q = self._visible_inline_comments_of_pull_request(pull_request)
             else:
                 q = self._all_inline_comments_of_pull_request(pull_request)
 
         else:
             raise Exception('Please specify commit or pull_request_id')
         q = q.order_by(ChangesetComment.comment_id.asc())
         return q
 
     def _group_comments_by_path_and_line_number(self, q):
         comments = q.all()
         paths = collections.defaultdict(lambda: collections.defaultdict(list))
         for co in comments:
             paths[co.f_path][co.line_no].append(co)
         return paths
 
     @classmethod
     def needed_extra_diff_context(cls):
         return max(cls.DIFF_CONTEXT_BEFORE, cls.DIFF_CONTEXT_AFTER)
 
     def outdate_comments(self, pull_request, old_diff_data, new_diff_data):
         if not CommentsModel.use_outdated_comments(pull_request):
             return
 
         comments = self._visible_inline_comments_of_pull_request(pull_request)
         comments_to_outdate = comments.all()
 
         for comment in comments_to_outdate:
             self._outdate_one_comment(comment, old_diff_data, new_diff_data)
 
     def _outdate_one_comment(self, comment, old_diff_proc, new_diff_proc):
         diff_line = _parse_comment_line_number(comment.line_no)
 
         try:
             old_context = old_diff_proc.get_context_of_line(
                 path=comment.f_path, diff_line=diff_line)
             new_context = new_diff_proc.get_context_of_line(
                 path=comment.f_path, diff_line=diff_line)
         except (diffs.LineNotInDiffException,
                 diffs.FileNotInDiffException):
             comment.display_state = ChangesetComment.COMMENT_OUTDATED
             return
 
         if old_context == new_context:
             return
 
         if self._should_relocate_diff_line(diff_line):
             new_diff_lines = new_diff_proc.find_context(
                 path=comment.f_path, context=old_context,
                 offset=self.DIFF_CONTEXT_BEFORE)
             if not new_diff_lines:
                 comment.display_state = ChangesetComment.COMMENT_OUTDATED
             else:
                 new_diff_line = self._choose_closest_diff_line(
                     diff_line, new_diff_lines)
                 comment.line_no = _diff_to_comment_line_number(new_diff_line)
         else:
             comment.display_state = ChangesetComment.COMMENT_OUTDATED
 
     def _should_relocate_diff_line(self, diff_line):
         """
         Checks if relocation shall be tried for the given `diff_line`.
 
         If a comment points into the first lines, then we can have a situation
         that after an update another line has been added on top. In this case
         we would find the context still and move the comment around. This
         would be wrong.
         """
         should_relocate = (
             (diff_line.new and diff_line.new > self.DIFF_CONTEXT_BEFORE) or
             (diff_line.old and diff_line.old > self.DIFF_CONTEXT_BEFORE))
         return should_relocate
 
     def _choose_closest_diff_line(self, diff_line, new_diff_lines):
         candidate = new_diff_lines[0]
         best_delta = _diff_line_delta(diff_line, candidate)
         for new_diff_line in new_diff_lines[1:]:
             delta = _diff_line_delta(diff_line, new_diff_line)
             if delta < best_delta:
                 candidate = new_diff_line
                 best_delta = delta
         return candidate
 
     def _visible_inline_comments_of_pull_request(self, pull_request):
         comments = self._all_inline_comments_of_pull_request(pull_request)
         comments = comments.filter(
             coalesce(ChangesetComment.display_state, '') !=
             ChangesetComment.COMMENT_OUTDATED)
         return comments
 
     def _all_inline_comments_of_pull_request(self, pull_request):
         comments = Session().query(ChangesetComment)\
             .filter(ChangesetComment.line_no != None)\
             .filter(ChangesetComment.f_path != None)\
             .filter(ChangesetComment.pull_request == pull_request)
         return comments
 
     def _all_general_comments_of_pull_request(self, pull_request):
         comments = Session().query(ChangesetComment)\
             .filter(ChangesetComment.line_no == None)\
             .filter(ChangesetComment.f_path == None)\
             .filter(ChangesetComment.pull_request == pull_request)
 
         return comments
 
     @staticmethod
     def use_outdated_comments(pull_request):
         settings_model = VcsSettingsModel(repo=pull_request.target_repo)
         settings = settings_model.get_general_settings()
         return settings.get('rhodecode_use_outdated_comments', False)
 
     def trigger_commit_comment_hook(self, repo, user, action, data=None):
         repo = self._get_repo(repo)
         target_scm = repo.scm_instance()
         if action == 'create':
             trigger_hook = hooks_utils.trigger_comment_commit_hooks
         elif action == 'edit':
             trigger_hook = hooks_utils.trigger_comment_commit_edit_hooks
         else:
             return
 
         log.debug('Handling repo %s trigger_commit_comment_hook with action %s: %s',
                   repo, action, trigger_hook)
         trigger_hook(
             username=user.username,
             repo_name=repo.repo_name,
             repo_type=target_scm.alias,
             repo=repo,
             data=data)
 
 
 def _parse_comment_line_number(line_no):
     """
     Parses line numbers of the form "(o|n)\d+" and returns them in a tuple.
     """
     old_line = None
     new_line = None
     if line_no.startswith('o'):
         old_line = int(line_no[1:])
     elif line_no.startswith('n'):
         new_line = int(line_no[1:])
     else:
         raise ValueError("Comment lines have to start with either 'o' or 'n'.")
     return diffs.DiffLineNumber(old_line, new_line)
 
 
 def _diff_to_comment_line_number(diff_line):
     if diff_line.new is not None:
         return u'n{}'.format(diff_line.new)
     elif diff_line.old is not None:
         return u'o{}'.format(diff_line.old)
     return u''
 
 
 def _diff_line_delta(a, b):
     if None not in (a.new, b.new):
         return abs(a.new - b.new)
     elif None not in (a.old, b.old):
         return abs(a.old - b.old)
     else:
         raise ValueError(
             "Cannot compute delta between {} and {}".format(a, b))

rhodecode/model/db.py

@@ -1,5740 +1,5794 b''
 # -*- coding: utf-8 -*-
 
 # Copyright (C) 2010-2020 RhodeCode GmbH
 #
 # This program is free software: you can redistribute it and/or modify
 # it under the terms of the GNU Affero General Public License, version 3
 # (only), as published by the Free Software Foundation.
 #
 # 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 Affero General Public License
 # along with this program.  If not, see <http://www.gnu.org/licenses/>.
 #
 # This program is dual-licensed. If you wish to learn more about the
 # RhodeCode Enterprise Edition, including its added features, Support services,
 # and proprietary license terms, please see https://rhodecode.com/licenses/
 
 """
 Database Models for RhodeCode Enterprise
 """
 
 import re
 import os
 import time
 import string
 import hashlib
 import logging
 import datetime
 import uuid
 import warnings
 import ipaddress
 import functools
 import traceback
 import collections
 
 from sqlalchemy import (
     or_, and_, not_, func, cast, TypeDecorator, event,
     Index, Sequence, UniqueConstraint, ForeignKey, CheckConstraint, Column,
     Boolean, String, Unicode, UnicodeText, DateTime, Integer, LargeBinary,
     Text, Float, PickleType, BigInteger)
 from sqlalchemy.sql.expression import true, false, case
 from sqlalchemy.sql.functions import coalesce, count  # pragma: no cover
 from sqlalchemy.orm import (
     relationship, joinedload, class_mapper, validates, aliased)
 from sqlalchemy.ext.declarative import declared_attr
 from sqlalchemy.ext.hybrid import hybrid_property
 from sqlalchemy.exc import IntegrityError  # pragma: no cover
 from sqlalchemy.dialects.mysql import LONGTEXT
 from zope.cachedescriptors.property import Lazy as LazyProperty
 from pyramid import compat
 from pyramid.threadlocal import get_current_request
 from webhelpers2.text import remove_formatting
 
 from rhodecode.translation import _
 from rhodecode.lib.vcs import get_vcs_instance, VCSError
 from rhodecode.lib.vcs.backends.base import EmptyCommit, Reference
 from rhodecode.lib.utils2 import (
     str2bool, safe_str, get_commit_safe, safe_unicode, sha1_safe,
     time_to_datetime, aslist, Optional, safe_int, get_clone_url, AttributeDict,
     glob2re, StrictAttributeDict, cleaned_uri, datetime_to_time, OrderedDefaultDict)
 from rhodecode.lib.jsonalchemy import MutationObj, MutationList, JsonType, \
     JsonRaw
 from rhodecode.lib.ext_json import json
 from rhodecode.lib.caching_query import FromCache
 from rhodecode.lib.encrypt import AESCipher, validate_and_get_enc_data
 from rhodecode.lib.encrypt2 import Encryptor
 from rhodecode.lib.exceptions import (
     ArtifactMetadataDuplicate, ArtifactMetadataBadValueType)
 from rhodecode.model.meta import Base, Session
 
 URL_SEP = '/'
 log = logging.getLogger(__name__)
 
 # =============================================================================
 # BASE CLASSES
 # =============================================================================
 
 # this is propagated from .ini file rhodecode.encrypted_values.secret or
 # beaker.session.secret if first is not set.
 # and initialized at environment.py
 ENCRYPTION_KEY = None
 
 # used to sort permissions by types, '#' used here is not allowed to be in
 # usernames, and it's very early in sorted string.printable table.
 PERMISSION_TYPE_SORT = {
     'admin': '####',
     'write': '###',
     'read':  '##',
     'none':  '#',
 }
 
 
 def display_user_sort(obj):
     """
     Sort function used to sort permissions in .permissions() function of
     Repository, RepoGroup, UserGroup. Also it put the default user in front
     of all other resources
     """
 
     if obj.username == User.DEFAULT_USER:
         return '#####'
     prefix = PERMISSION_TYPE_SORT.get(obj.permission.split('.')[-1], '')
     extra_sort_num = '1'  # default
 
     # NOTE(dan): inactive duplicates goes last
     if getattr(obj, 'duplicate_perm', None):
         extra_sort_num = '9'
     return prefix + extra_sort_num + obj.username
 
 
 def display_user_group_sort(obj):
     """
     Sort function used to sort permissions in .permissions() function of
     Repository, RepoGroup, UserGroup. Also it put the default user in front
     of all other resources
     """
 
     prefix = PERMISSION_TYPE_SORT.get(obj.permission.split('.')[-1], '')
     return prefix + obj.users_group_name
 
 
 def _hash_key(k):
     return sha1_safe(k)
 
 
 def in_filter_generator(qry, items, limit=500):
     """
     Splits IN() into multiple with OR
     e.g.::
     cnt = Repository.query().filter(
         or_(
             *in_filter_generator(Repository.repo_id, range(100000))
         )).count()
     """
     if not items:
         # empty list will cause empty query which might cause security issues
         # this can lead to hidden unpleasant results
         items = [-1]
 
     parts = []
     for chunk in xrange(0, len(items), limit):
         parts.append(
             qry.in_(items[chunk: chunk + limit])
         )
 
     return parts
 
 
 base_table_args = {
     'extend_existing': True,
     'mysql_engine': 'InnoDB',
     'mysql_charset': 'utf8',
     'sqlite_autoincrement': True
 }
 
 
 class EncryptedTextValue(TypeDecorator):
     """
     Special column for encrypted long text data, use like::
 
         value = Column("encrypted_value", EncryptedValue(), nullable=False)
 
     This column is intelligent so if value is in unencrypted form it return
     unencrypted form, but on save it always encrypts
     """
     impl = Text
 
     def process_bind_param(self, value, dialect):
         """
         Setter for storing value
         """
         import rhodecode
         if not value:
             return value
 
         # protect against double encrypting if values is already encrypted
         if value.startswith('enc$aes$') \
                 or value.startswith('enc$aes_hmac$') \
                 or value.startswith('enc2$'):
             raise ValueError('value needs to be in unencrypted format, '
                              'ie. not starting with enc$ or enc2$')
 
         algo = rhodecode.CONFIG.get('rhodecode.encrypted_values.algorithm') or 'aes'
         if algo == 'aes':
             return 'enc$aes_hmac$%s' % AESCipher(ENCRYPTION_KEY, hmac=True).encrypt(value)
         elif algo == 'fernet':
             return Encryptor(ENCRYPTION_KEY).encrypt(value)
         else:
             ValueError('Bad encryption algorithm, should be fernet or aes, got: {}'.format(algo))
 
     def process_result_value(self, value, dialect):
         """
         Getter for retrieving value
         """
 
         import rhodecode
         if not value:
             return value
 
         algo = rhodecode.CONFIG.get('rhodecode.encrypted_values.algorithm') or 'aes'
         enc_strict_mode = str2bool(rhodecode.CONFIG.get('rhodecode.encrypted_values.strict') or True)
         if algo == 'aes':
             decrypted_data = validate_and_get_enc_data(value, ENCRYPTION_KEY, enc_strict_mode)
         elif algo == 'fernet':
             return Encryptor(ENCRYPTION_KEY).decrypt(value)
         else:
             ValueError('Bad encryption algorithm, should be fernet or aes, got: {}'.format(algo))
         return decrypted_data
 
 
 class BaseModel(object):
     """
     Base Model for all classes
     """
 
     @classmethod
     def _get_keys(cls):
         """return column names for this model """
         return class_mapper(cls).c.keys()
 
     def get_dict(self):
         """
         return dict with keys and values corresponding
         to this model data """
 
         d = {}
         for k in self._get_keys():
             d[k] = getattr(self, k)
 
         # also use __json__() if present to get additional fields
         _json_attr = getattr(self, '__json__', None)
         if _json_attr:
             # update with attributes from __json__
             if callable(_json_attr):
                 _json_attr = _json_attr()
             for k, val in _json_attr.iteritems():
                 d[k] = val
         return d
 
     def get_appstruct(self):
         """return list with keys and values tuples corresponding
         to this model data """
 
         lst = []
         for k in self._get_keys():
             lst.append((k, getattr(self, k),))
         return lst
 
     def populate_obj(self, populate_dict):
         """populate model with data from given populate_dict"""
 
         for k in self._get_keys():
             if k in populate_dict:
                 setattr(self, k, populate_dict[k])
 
     @classmethod
     def query(cls):
         return Session().query(cls)
 
     @classmethod
     def get(cls, id_):
         if id_:
             return cls.query().get(id_)
 
     @classmethod
     def get_or_404(cls, id_):
         from pyramid.httpexceptions import HTTPNotFound
 
         try:
             id_ = int(id_)
         except (TypeError, ValueError):
             raise HTTPNotFound()
 
         res = cls.query().get(id_)
         if not res:
             raise HTTPNotFound()
         return res
 
     @classmethod
     def getAll(cls):
         # deprecated and left for backward compatibility
         return cls.get_all()
 
     @classmethod
     def get_all(cls):
         return cls.query().all()
 
     @classmethod
     def delete(cls, id_):
         obj = cls.query().get(id_)
         Session().delete(obj)
 
     @classmethod
     def identity_cache(cls, session, attr_name, value):
         exist_in_session = []
         for (item_cls, pkey), instance in session.identity_map.items():
             if cls == item_cls and getattr(instance, attr_name) == value:
                 exist_in_session.append(instance)
         if exist_in_session:
             if len(exist_in_session) == 1:
                 return exist_in_session[0]
             log.exception(
                 'multiple objects with attr %s and '
                 'value %s found with same name: %r',
                 attr_name, value, exist_in_session)
 
     def __repr__(self):
         if hasattr(self, '__unicode__'):
             # python repr needs to return str
             try:
                 return safe_str(self.__unicode__())
             except UnicodeDecodeError:
                 pass
         return '<DB:%s>' % (self.__class__.__name__)
 
 
 class RhodeCodeSetting(Base, BaseModel):
     __tablename__ = 'rhodecode_settings'
     __table_args__ = (
         UniqueConstraint('app_settings_name'),
         base_table_args
     )
 
     SETTINGS_TYPES = {
         'str': safe_str,
         'int': safe_int,
         'unicode': safe_unicode,
         'bool': str2bool,
         'list': functools.partial(aslist, sep=',')
     }
     DEFAULT_UPDATE_URL = 'https://rhodecode.com/api/v1/info/versions'
     GLOBAL_CONF_KEY = 'app_settings'
 
     app_settings_id = Column("app_settings_id", Integer(), nullable=False, unique=True, default=None, primary_key=True)
     app_settings_name = Column("app_settings_name", String(255), nullable=True, unique=None, default=None)
     _app_settings_value = Column("app_settings_value", String(4096), nullable=True, unique=None, default=None)
     _app_settings_type = Column("app_settings_type", String(255), nullable=True, unique=None, default=None)
 
     def __init__(self, key='', val='', type='unicode'):
         self.app_settings_name = key
         self.app_settings_type = type
         self.app_settings_value = val
 
     @validates('_app_settings_value')
     def validate_settings_value(self, key, val):
         assert type(val) == unicode
         return val
 
     @hybrid_property
     def app_settings_value(self):
         v = self._app_settings_value
         _type = self.app_settings_type
         if _type:
             _type = self.app_settings_type.split('.')[0]
             # decode the encrypted value
             if 'encrypted' in self.app_settings_type:
                 cipher = EncryptedTextValue()
                 v = safe_unicode(cipher.process_result_value(v, None))
 
         converter = self.SETTINGS_TYPES.get(_type) or \
             self.SETTINGS_TYPES['unicode']
         return converter(v)
 
     @app_settings_value.setter
     def app_settings_value(self, val):
         """
         Setter that will always make sure we use unicode in app_settings_value
 
         :param val:
         """
         val = safe_unicode(val)
         # encode the encrypted value
         if 'encrypted' in self.app_settings_type:
             cipher = EncryptedTextValue()
             val = safe_unicode(cipher.process_bind_param(val, None))
         self._app_settings_value = val
 
     @hybrid_property
     def app_settings_type(self):
         return self._app_settings_type
 
     @app_settings_type.setter
     def app_settings_type(self, val):
         if val.split('.')[0] not in self.SETTINGS_TYPES:
             raise Exception('type must be one of %s got %s'
                             % (self.SETTINGS_TYPES.keys(), val))
         self._app_settings_type = val
 
     @classmethod
     def get_by_prefix(cls, prefix):
         return RhodeCodeSetting.query()\
             .filter(RhodeCodeSetting.app_settings_name.startswith(prefix))\
             .all()
 
     def __unicode__(self):
         return u"<%s('%s:%s[%s]')>" % (
             self.__class__.__name__,
             self.app_settings_name, self.app_settings_value,
             self.app_settings_type
         )
 
 
 class RhodeCodeUi(Base, BaseModel):
     __tablename__ = 'rhodecode_ui'
     __table_args__ = (
         UniqueConstraint('ui_key'),
         base_table_args
     )
 
     HOOK_REPO_SIZE = 'changegroup.repo_size'
     # HG
     HOOK_PRE_PULL = 'preoutgoing.pre_pull'
     HOOK_PULL = 'outgoing.pull_logger'
     HOOK_PRE_PUSH = 'prechangegroup.pre_push'
     HOOK_PRETX_PUSH = 'pretxnchangegroup.pre_push'
     HOOK_PUSH = 'changegroup.push_logger'
     HOOK_PUSH_KEY = 'pushkey.key_push'
 
     HOOKS_BUILTIN = [
         HOOK_PRE_PULL,
         HOOK_PULL,
         HOOK_PRE_PUSH,
         HOOK_PRETX_PUSH,
         HOOK_PUSH,
         HOOK_PUSH_KEY,
     ]
 
     # TODO: johbo: Unify way how hooks are configured for git and hg,
     # git part is currently hardcoded.
 
     # SVN PATTERNS
     SVN_BRANCH_ID = 'vcs_svn_branch'
     SVN_TAG_ID = 'vcs_svn_tag'
 
     ui_id = Column(
         "ui_id", Integer(), nullable=False, unique=True, default=None,
         primary_key=True)
     ui_section = Column(
         "ui_section", String(255), nullable=True, unique=None, default=None)
     ui_key = Column(
         "ui_key", String(255), nullable=True, unique=None, default=None)
     ui_value = Column(
         "ui_value", String(255), nullable=True, unique=None, default=None)
     ui_active = Column(
         "ui_active", Boolean(), nullable=True, unique=None, default=True)
 
     def __repr__(self):
         return '<%s[%s]%s=>%s]>' % (self.__class__.__name__, self.ui_section,
                                     self.ui_key, self.ui_value)
 
 
 class RepoRhodeCodeSetting(Base, BaseModel):
     __tablename__ = 'repo_rhodecode_settings'
     __table_args__ = (
         UniqueConstraint(
             'app_settings_name', 'repository_id',
             name='uq_repo_rhodecode_setting_name_repo_id'),
         base_table_args
     )
 
     repository_id = Column(
         "repository_id", Integer(), ForeignKey('repositories.repo_id'),
         nullable=False)
     app_settings_id = Column(
         "app_settings_id", Integer(), nullable=False, unique=True,
         default=None, primary_key=True)
     app_settings_name = Column(
         "app_settings_name", String(255), nullable=True, unique=None,
         default=None)
     _app_settings_value = Column(
         "app_settings_value", String(4096), nullable=True, unique=None,
         default=None)
     _app_settings_type = Column(
         "app_settings_type", String(255), nullable=True, unique=None,
         default=None)
 
     repository = relationship('Repository')
 
     def __init__(self, repository_id, key='', val='', type='unicode'):
         self.repository_id = repository_id
         self.app_settings_name = key
         self.app_settings_type = type
         self.app_settings_value = val
 
     @validates('_app_settings_value')
     def validate_settings_value(self, key, val):
         assert type(val) == unicode
         return val
 
     @hybrid_property
     def app_settings_value(self):
         v = self._app_settings_value
         type_ = self.app_settings_type
         SETTINGS_TYPES = RhodeCodeSetting.SETTINGS_TYPES
         converter = SETTINGS_TYPES.get(type_) or SETTINGS_TYPES['unicode']
         return converter(v)
 
     @app_settings_value.setter
     def app_settings_value(self, val):
         """
         Setter that will always make sure we use unicode in app_settings_value
 
         :param val:
         """
         self._app_settings_value = safe_unicode(val)
 
     @hybrid_property
     def app_settings_type(self):
         return self._app_settings_type
 
     @app_settings_type.setter
     def app_settings_type(self, val):
         SETTINGS_TYPES = RhodeCodeSetting.SETTINGS_TYPES
         if val not in SETTINGS_TYPES:
             raise Exception('type must be one of %s got %s'
                             % (SETTINGS_TYPES.keys(), val))
         self._app_settings_type = val
 
     def __unicode__(self):
         return u"<%s('%s:%s:%s[%s]')>" % (
             self.__class__.__name__, self.repository.repo_name,
             self.app_settings_name, self.app_settings_value,
             self.app_settings_type
         )
 
 
 class RepoRhodeCodeUi(Base, BaseModel):
     __tablename__ = 'repo_rhodecode_ui'
     __table_args__ = (
         UniqueConstraint(
             'repository_id', 'ui_section', 'ui_key',
             name='uq_repo_rhodecode_ui_repository_id_section_key'),
         base_table_args
     )
 
     repository_id = Column(
         "repository_id", Integer(), ForeignKey('repositories.repo_id'),
         nullable=False)
     ui_id = Column(
         "ui_id", Integer(), nullable=False, unique=True, default=None,
         primary_key=True)
     ui_section = Column(
         "ui_section", String(255), nullable=True, unique=None, default=None)
     ui_key = Column(
         "ui_key", String(255), nullable=True, unique=None, default=None)
     ui_value = Column(
         "ui_value", String(255), nullable=True, unique=None, default=None)
     ui_active = Column(
         "ui_active", Boolean(), nullable=True, unique=None, default=True)
 
     repository = relationship('Repository')
 
     def __repr__(self):
         return '<%s[%s:%s]%s=>%s]>' % (
             self.__class__.__name__, self.repository.repo_name,
             self.ui_section, self.ui_key, self.ui_value)
 
 
 class User(Base, BaseModel):
     __tablename__ = 'users'
     __table_args__ = (
         UniqueConstraint('username'), UniqueConstraint('email'),
         Index('u_username_idx', 'username'),
         Index('u_email_idx', 'email'),
         base_table_args
     )
 
     DEFAULT_USER = 'default'
     DEFAULT_USER_EMAIL = '[e-mail]'
     DEFAULT_GRAVATAR_URL = 'https://secure.gravatar.com/avatar/{md5email}?d=identicon&s={size}'
 
     user_id = Column("user_id", Integer(), nullable=False, unique=True, default=None, primary_key=True)
     username = Column("username", String(255), nullable=True, unique=None, default=None)
     password = Column("password", String(255), nullable=True, unique=None, default=None)
     active = Column("active", Boolean(), nullable=True, unique=None, default=True)
     admin = Column("admin", Boolean(), nullable=True, unique=None, default=False)
     name = Column("firstname", String(255), nullable=True, unique=None, default=None)
     lastname = Column("lastname", String(255), nullable=True, unique=None, default=None)
     _email = Column("email", String(255), nullable=True, unique=None, default=None)
     last_login = Column("last_login", DateTime(timezone=False), nullable=True, unique=None, default=None)
     last_activity = Column('last_activity', DateTime(timezone=False), nullable=True, unique=None, default=None)
     description = Column('description', UnicodeText().with_variant(UnicodeText(1024), 'mysql'))
 
     extern_type = Column("extern_type", String(255), nullable=True, unique=None, default=None)
     extern_name = Column("extern_name", String(255), nullable=True, unique=None, default=None)
     _api_key = Column("api_key", String(255), nullable=True, unique=None, default=None)
     inherit_default_permissions = Column("inherit_default_permissions", Boolean(), nullable=False, unique=None, default=True)
     created_on = Column('created_on', DateTime(timezone=False), nullable=False, default=datetime.datetime.now)
     _user_data = Column("user_data", LargeBinary(), nullable=True)  # JSON data
 
     user_log = relationship('UserLog')
     user_perms = relationship('UserToPerm', primaryjoin="User.user_id==UserToPerm.user_id", cascade='all, delete-orphan')
 
     repositories = relationship('Repository')
     repository_groups = relationship('RepoGroup')
     user_groups = relationship('UserGroup')
 
     user_followers = relationship('UserFollowing', primaryjoin='UserFollowing.follows_user_id==User.user_id', cascade='all')
     followings = relationship('UserFollowing', primaryjoin='UserFollowing.user_id==User.user_id', cascade='all')
 
     repo_to_perm = relationship('UserRepoToPerm', primaryjoin='UserRepoToPerm.user_id==User.user_id', cascade='all, delete-orphan')
     repo_group_to_perm = relationship('UserRepoGroupToPerm', primaryjoin='UserRepoGroupToPerm.user_id==User.user_id', cascade='all, delete-orphan')
     user_group_to_perm = relationship('UserUserGroupToPerm', primaryjoin='UserUserGroupToPerm.user_id==User.user_id', cascade='all, delete-orphan')
 
     group_member = relationship('UserGroupMember', cascade='all')
 
     notifications = relationship('UserNotification', cascade='all')
     # notifications assigned to this user
     user_created_notifications = relationship('Notification', cascade='all')
     # comments created by this user
     user_comments = relationship('ChangesetComment', cascade='all')
     # user profile extra info
     user_emails = relationship('UserEmailMap', cascade='all')
     user_ip_map = relationship('UserIpMap', cascade='all')
     user_auth_tokens = relationship('UserApiKeys', cascade='all')
     user_ssh_keys = relationship('UserSshKeys', cascade='all')
 
     # gists
     user_gists = relationship('Gist', cascade='all')
     # user pull requests
     user_pull_requests = relationship('PullRequest', cascade='all')
 
     # external identities
     external_identities = relationship(
         'ExternalIdentity',
         primaryjoin="User.user_id==ExternalIdentity.local_user_id",
         cascade='all')
     # review rules
     user_review_rules = relationship('RepoReviewRuleUser', cascade='all')
 
     # artifacts owned
     artifacts = relationship('FileStore', primaryjoin='FileStore.user_id==User.user_id')
 
     # no cascade, set NULL
     scope_artifacts = relationship('FileStore', primaryjoin='FileStore.scope_user_id==User.user_id')
 
     def __unicode__(self):
         return u"<%s('id:%s:%s')>" % (self.__class__.__name__,
                                       self.user_id, self.username)
 
     @hybrid_property
     def email(self):
         return self._email
 
     @email.setter
     def email(self, val):
         self._email = val.lower() if val else None
 
     @hybrid_property
     def first_name(self):
         from rhodecode.lib import helpers as h
         if self.name:
             return h.escape(self.name)
         return self.name
 
     @hybrid_property
     def last_name(self):
         from rhodecode.lib import helpers as h
         if self.lastname:
             return h.escape(self.lastname)
         return self.lastname
 
     @hybrid_property
     def api_key(self):
         """
         Fetch if exist an auth-token with role ALL connected to this user
         """
         user_auth_token = UserApiKeys.query()\
             .filter(UserApiKeys.user_id == self.user_id)\
             .filter(or_(UserApiKeys.expires == -1,
                             UserApiKeys.expires >= time.time()))\
             .filter(UserApiKeys.role == UserApiKeys.ROLE_ALL).first()
         if user_auth_token:
             user_auth_token = user_auth_token.api_key
 
         return user_auth_token
 
     @api_key.setter
     def api_key(self, val):
         # don't allow to set API key this is deprecated for now
         self._api_key = None
 
     @property
     def reviewer_pull_requests(self):
         return PullRequestReviewers.query() \
             .options(joinedload(PullRequestReviewers.pull_request)) \
             .filter(PullRequestReviewers.user_id == self.user_id) \
             .all()
 
     @property
     def firstname(self):
         # alias for future
         return self.name
 
     @property
     def emails(self):
         other = UserEmailMap.query()\
             .filter(UserEmailMap.user == self) \
             .order_by(UserEmailMap.email_id.asc()) \
             .all()
         return [self.email] + [x.email for x in other]
 
     def emails_cached(self):
         emails = UserEmailMap.query()\
             .filter(UserEmailMap.user == self) \
             .order_by(UserEmailMap.email_id.asc())
 
         emails = emails.options(
             FromCache("sql_cache_short", "get_user_{}_emails".format(self.user_id))
         )
 
         return [self.email] + [x.email for x in emails]
 
     @property
     def auth_tokens(self):
         auth_tokens = self.get_auth_tokens()
         return [x.api_key for x in auth_tokens]
 
     def get_auth_tokens(self):
         return UserApiKeys.query()\
             .filter(UserApiKeys.user == self)\
             .order_by(UserApiKeys.user_api_key_id.asc())\
             .all()
 
     @LazyProperty
     def feed_token(self):
         return self.get_feed_token()
 
     def get_feed_token(self, cache=True):
         feed_tokens = UserApiKeys.query()\
             .filter(UserApiKeys.user == self)\
             .filter(UserApiKeys.role == UserApiKeys.ROLE_FEED)
         if cache:
             feed_tokens = feed_tokens.options(
                 FromCache("sql_cache_short", "get_user_feed_token_%s" % self.user_id))
 
         feed_tokens = feed_tokens.all()
         if feed_tokens:
             return feed_tokens[0].api_key
         return 'NO_FEED_TOKEN_AVAILABLE'
 
     @LazyProperty
     def artifact_token(self):
         return self.get_artifact_token()
 
     def get_artifact_token(self, cache=True):
         artifacts_tokens = UserApiKeys.query()\
             .filter(UserApiKeys.user == self)\
             .filter(UserApiKeys.role == UserApiKeys.ROLE_ARTIFACT_DOWNLOAD)
         if cache:
             artifacts_tokens = artifacts_tokens.options(
                 FromCache("sql_cache_short", "get_user_artifact_token_%s" % self.user_id))
 
         artifacts_tokens = artifacts_tokens.all()
         if artifacts_tokens:
             return artifacts_tokens[0].api_key
         return 'NO_ARTIFACT_TOKEN_AVAILABLE'
 
     @classmethod
     def get(cls, user_id, cache=False):
         if not user_id:
             return
 
         user = cls.query()
         if cache:
             user = user.options(
                 FromCache("sql_cache_short", "get_users_%s" % user_id))
         return user.get(user_id)
 
     @classmethod
     def extra_valid_auth_tokens(cls, user, role=None):
         tokens = UserApiKeys.query().filter(UserApiKeys.user == user)\
                 .filter(or_(UserApiKeys.expires == -1,
                             UserApiKeys.expires >= time.time()))
         if role:
             tokens = tokens.filter(or_(UserApiKeys.role == role,
                                        UserApiKeys.role == UserApiKeys.ROLE_ALL))
         return tokens.all()
 
     def authenticate_by_token(self, auth_token, roles=None, scope_repo_id=None):
         from rhodecode.lib import auth
 
         log.debug('Trying to authenticate user: %s via auth-token, '
                   'and roles: %s', self, roles)
 
         if not auth_token:
             return False
 
         roles = (roles or []) + [UserApiKeys.ROLE_ALL]
         tokens_q = UserApiKeys.query()\
             .filter(UserApiKeys.user_id == self.user_id)\
             .filter(or_(UserApiKeys.expires == -1,
                         UserApiKeys.expires >= time.time()))
 
         tokens_q = tokens_q.filter(UserApiKeys.role.in_(roles))
 
         crypto_backend = auth.crypto_backend()
         enc_token_map = {}
         plain_token_map = {}
         for token in tokens_q:
             if token.api_key.startswith(crypto_backend.ENC_PREF):
                 enc_token_map[token.api_key] = token
             else:
                 plain_token_map[token.api_key] = token
         log.debug(
             'Found %s plain and %s encrypted tokens to check for authentication for this user',
             len(plain_token_map), len(enc_token_map))
 
         # plain token match comes first
         match = plain_token_map.get(auth_token)
 
         # check encrypted tokens now
         if not match:
             for token_hash, token in enc_token_map.items():
                 # NOTE(marcink): this is expensive to calculate, but most secure
                 if crypto_backend.hash_check(auth_token, token_hash):
                     match = token
                     break
 
         if match:
             log.debug('Found matching token %s', match)
             if match.repo_id:
                 log.debug('Found scope, checking for scope match of token %s', match)
                 if match.repo_id == scope_repo_id:
                     return True
                 else:
                     log.debug(
                         'AUTH_TOKEN: scope mismatch, token has a set repo scope: %s, '
                         'and calling scope is:%s, skipping further checks',
                          match.repo, scope_repo_id)
                     return False
             else:
                 return True
 
         return False
 
     @property
     def ip_addresses(self):
         ret = UserIpMap.query().filter(UserIpMap.user == self).all()
         return [x.ip_addr for x in ret]
 
     @property
     def username_and_name(self):
         return '%s (%s %s)' % (self.username, self.first_name, self.last_name)
 
     @property
     def username_or_name_or_email(self):
         full_name = self.full_name if self.full_name is not ' ' else None
         return self.username or full_name or self.email
 
     @property
     def full_name(self):
         return '%s %s' % (self.first_name, self.last_name)
 
     @property
     def full_name_or_username(self):
         return ('%s %s' % (self.first_name, self.last_name)
                 if (self.first_name and self.last_name) else self.username)
 
     @property
     def full_contact(self):
         return '%s %s <%s>' % (self.first_name, self.last_name, self.email)
 
     @property
     def short_contact(self):
         return '%s %s' % (self.first_name, self.last_name)
 
     @property
     def is_admin(self):
         return self.admin
 
     @property
     def language(self):
         return self.user_data.get('language')
 
     def AuthUser(self, **kwargs):
         """
         Returns instance of AuthUser for this user
         """
         from rhodecode.lib.auth import AuthUser
         return AuthUser(user_id=self.user_id, username=self.username, **kwargs)
 
     @hybrid_property
     def user_data(self):
         if not self._user_data:
             return {}
 
         try:
             return json.loads(self._user_data)
         except TypeError:
             return {}
 
     @user_data.setter
     def user_data(self, val):
         if not isinstance(val, dict):
             raise Exception('user_data must be dict, got %s' % type(val))
         try:
             self._user_data = json.dumps(val)
         except Exception:
             log.error(traceback.format_exc())
 
     @classmethod
     def get_by_username(cls, username, case_insensitive=False,
                         cache=False, identity_cache=False):
         session = Session()
 
         if case_insensitive:
             q = cls.query().filter(
                 func.lower(cls.username) == func.lower(username))
         else:
             q = cls.query().filter(cls.username == username)
 
         if cache:
             if identity_cache:
                 val = cls.identity_cache(session, 'username', username)
                 if val:
                     return val
             else:
                 cache_key = "get_user_by_name_%s" % _hash_key(username)
                 q = q.options(
                     FromCache("sql_cache_short", cache_key))
 
         return q.scalar()
 
     @classmethod
     def get_by_auth_token(cls, auth_token, cache=False):
         q = UserApiKeys.query()\
             .filter(UserApiKeys.api_key == auth_token)\
             .filter(or_(UserApiKeys.expires == -1,
                         UserApiKeys.expires >= time.time()))
         if cache:
             q = q.options(
                 FromCache("sql_cache_short", "get_auth_token_%s" % auth_token))
 
         match = q.first()
         if match:
             return match.user
 
     @classmethod
     def get_by_email(cls, email, case_insensitive=False, cache=False):
 
         if case_insensitive:
             q = cls.query().filter(func.lower(cls.email) == func.lower(email))
 
         else:
             q = cls.query().filter(cls.email == email)
 
         email_key = _hash_key(email)
         if cache:
             q = q.options(
                 FromCache("sql_cache_short", "get_email_key_%s" % email_key))
 
         ret = q.scalar()
         if ret is None:
             q = UserEmailMap.query()
             # try fetching in alternate email map
             if case_insensitive:
                 q = q.filter(func.lower(UserEmailMap.email) == func.lower(email))
             else:
                 q = q.filter(UserEmailMap.email == email)
             q = q.options(joinedload(UserEmailMap.user))
             if cache:
                 q = q.options(
                     FromCache("sql_cache_short", "get_email_map_key_%s" % email_key))
             ret = getattr(q.scalar(), 'user', None)
 
         return ret
 
     @classmethod
     def get_from_cs_author(cls, author):
         """
         Tries to get User objects out of commit author string
 
         :param author:
         """
         from rhodecode.lib.helpers import email, author_name
         # Valid email in the attribute passed, see if they're in the system
         _email = email(author)
         if _email:
             user = cls.get_by_email(_email, case_insensitive=True)
             if user:
                 return user
         # Maybe we can match by username?
         _author = author_name(author)
         user = cls.get_by_username(_author, case_insensitive=True)
         if user:
             return user
 
     def update_userdata(self, **kwargs):
         usr = self
         old = usr.user_data
         old.update(**kwargs)
         usr.user_data = old
         Session().add(usr)
         log.debug('updated userdata with %s', kwargs)
 
     def update_lastlogin(self):
         """Update user lastlogin"""
         self.last_login = datetime.datetime.now()
         Session().add(self)
         log.debug('updated user %s lastlogin', self.username)
 
     def update_password(self, new_password):
         from rhodecode.lib.auth import get_crypt_password
 
         self.password = get_crypt_password(new_password)
         Session().add(self)
 
     @classmethod
     def get_first_super_admin(cls):
         user = User.query()\
             .filter(User.admin == true()) \
             .order_by(User.user_id.asc()) \
             .first()
 
         if user is None:
             raise Exception('FATAL: Missing administrative account!')
         return user
 
     @classmethod
     def get_all_super_admins(cls, only_active=False):
         """
         Returns all admin accounts sorted by username
         """
         qry = User.query().filter(User.admin == true()).order_by(User.username.asc())
         if only_active:
             qry = qry.filter(User.active == true())
         return qry.all()
 
     @classmethod
     def get_all_user_ids(cls, only_active=True):
         """
         Returns all users IDs
         """
         qry = Session().query(User.user_id)
 
         if only_active:
             qry = qry.filter(User.active == true())
         return [x.user_id for x in qry]
 
     @classmethod
     def get_default_user(cls, cache=False, refresh=False):
         user = User.get_by_username(User.DEFAULT_USER, cache=cache)
         if user is None:
             raise Exception('FATAL: Missing default account!')
         if refresh:
             # The default user might be based on outdated state which
             # has been loaded from the cache.
             # A call to refresh() ensures that the
             # latest state from the database is used.
             Session().refresh(user)
         return user
 
     @classmethod
     def get_default_user_id(cls):
         import rhodecode
         return rhodecode.CONFIG['default_user_id']
 
     def _get_default_perms(self, user, suffix=''):
         from rhodecode.model.permission import PermissionModel
         return PermissionModel().get_default_perms(user.user_perms, suffix)
 
     def get_default_perms(self, suffix=''):
         return self._get_default_perms(self, suffix)
 
     def get_api_data(self, include_secrets=False, details='full'):
         """
         Common function for generating user related data for API
 
         :param include_secrets: By default secrets in the API data will be replaced
            by a placeholder value to prevent exposing this data by accident. In case
            this data shall be exposed, set this flag to ``True``.
 
         :param details: details can be 'basic|full' basic gives only a subset of
            the available user information that includes user_id, name and emails.
         """
         user = self
         user_data = self.user_data
         data = {
             'user_id': user.user_id,
             'username': user.username,
             'firstname': user.name,
             'lastname': user.lastname,
             'description': user.description,
             'email': user.email,
             'emails': user.emails,
         }
         if details == 'basic':
             return data
 
         auth_token_length = 40
         auth_token_replacement = '*' * auth_token_length
 
         extras = {
             'auth_tokens': [auth_token_replacement],
             'active': user.active,
             'admin': user.admin,
             'extern_type': user.extern_type,
             'extern_name': user.extern_name,
             'last_login': user.last_login,
             'last_activity': user.last_activity,
             'ip_addresses': user.ip_addresses,
             'language': user_data.get('language')
         }
         data.update(extras)
 
         if include_secrets:
             data['auth_tokens'] = user.auth_tokens
         return data
 
     def __json__(self):
         data = {
             'full_name': self.full_name,
             'full_name_or_username': self.full_name_or_username,
             'short_contact': self.short_contact,
             'full_contact': self.full_contact,
         }
         data.update(self.get_api_data())
         return data
 
 
 class UserApiKeys(Base, BaseModel):
     __tablename__ = 'user_api_keys'
     __table_args__ = (
         Index('uak_api_key_idx', 'api_key'),
         Index('uak_api_key_expires_idx', 'api_key', 'expires'),
         base_table_args
     )
     __mapper_args__ = {}
 
     # ApiKey role
     ROLE_ALL = 'token_role_all'
     ROLE_VCS = 'token_role_vcs'
     ROLE_API = 'token_role_api'
     ROLE_HTTP = 'token_role_http'
     ROLE_FEED = 'token_role_feed'
     ROLE_ARTIFACT_DOWNLOAD = 'role_artifact_download'
     # The last one is ignored in the list as we only
     # use it for one action, and cannot be created by users
     ROLE_PASSWORD_RESET = 'token_password_reset'
 
     ROLES = [ROLE_ALL, ROLE_VCS, ROLE_API, ROLE_HTTP, ROLE_FEED, ROLE_ARTIFACT_DOWNLOAD]
 
     user_api_key_id = Column("user_api_key_id", Integer(), nullable=False, unique=True, default=None, primary_key=True)
     user_id = Column("user_id", Integer(), ForeignKey('users.user_id'), nullable=True, unique=None, default=None)
     api_key = Column("api_key", String(255), nullable=False, unique=True)
     description = Column('description', UnicodeText().with_variant(UnicodeText(1024), 'mysql'))
     expires = Column('expires', Float(53), nullable=False)
     role = Column('role', String(255), nullable=True)
     created_on = Column('created_on', DateTime(timezone=False), nullable=False, default=datetime.datetime.now)
 
     # scope columns
     repo_id = Column(
         'repo_id', Integer(), ForeignKey('repositories.repo_id'),
         nullable=True, unique=None, default=None)
     repo = relationship('Repository', lazy='joined')
 
     repo_group_id = Column(
         'repo_group_id', Integer(), ForeignKey('groups.group_id'),
         nullable=True, unique=None, default=None)
     repo_group = relationship('RepoGroup', lazy='joined')
 
     user = relationship('User', lazy='joined')
 
     def __unicode__(self):
         return u"<%s('%s')>" % (self.__class__.__name__, self.role)
 
     def __json__(self):
         data = {
             'auth_token': self.api_key,
             'role': self.role,
             'scope': self.scope_humanized,
             'expired': self.expired
         }
         return data
 
     def get_api_data(self, include_secrets=False):
         data = self.__json__()
         if include_secrets:
             return data
         else:
             data['auth_token'] = self.token_obfuscated
             return data
 
     @hybrid_property
     def description_safe(self):
         from rhodecode.lib import helpers as h
         return h.escape(self.description)
 
     @property
     def expired(self):
         if self.expires == -1:
             return False
         return time.time() > self.expires
 
     @classmethod
     def _get_role_name(cls, role):
         return {
             cls.ROLE_ALL: _('all'),
             cls.ROLE_HTTP: _('http/web interface'),
             cls.ROLE_VCS: _('vcs (git/hg/svn protocol)'),
             cls.ROLE_API: _('api calls'),
             cls.ROLE_FEED: _('feed access'),
             cls.ROLE_ARTIFACT_DOWNLOAD: _('artifacts downloads'),
         }.get(role, role)
 
     @classmethod
     def _get_role_description(cls, role):
         return {
             cls.ROLE_ALL: _('Token for all actions.'),
             cls.ROLE_HTTP: _('Token to access RhodeCode pages via web interface without '
                              'login using `api_access_controllers_whitelist` functionality.'),
             cls.ROLE_VCS: _('Token to interact over git/hg/svn protocols. '
                             'Requires auth_token authentication plugin to be active. <br/>'
                             'Such Token should be used then instead of a password to '
                             'interact with a repository, and additionally can be '
                             'limited to single repository using repo scope.'),
             cls.ROLE_API: _('Token limited to api calls.'),
             cls.ROLE_FEED: _('Token to read RSS/ATOM feed.'),
             cls.ROLE_ARTIFACT_DOWNLOAD: _('Token for artifacts downloads.'),
         }.get(role, role)
 
     @property
     def role_humanized(self):
         return self._get_role_name(self.role)
 
     def _get_scope(self):
         if self.repo:
             return 'Repository: {}'.format(self.repo.repo_name)
         if self.repo_group:
             return 'RepositoryGroup: {} (recursive)'.format(self.repo_group.group_name)
         return 'Global'
 
     @property
     def scope_humanized(self):
         return self._get_scope()
 
     @property
     def token_obfuscated(self):
         if self.api_key:
             return self.api_key[:4] + "****"
 
 
 class UserEmailMap(Base, BaseModel):
     __tablename__ = 'user_email_map'
     __table_args__ = (
         Index('uem_email_idx', 'email'),
         UniqueConstraint('email'),
         base_table_args
     )
     __mapper_args__ = {}
 
     email_id = Column("email_id", Integer(), nullable=False, unique=True, default=None, primary_key=True)
     user_id = Column("user_id", Integer(), ForeignKey('users.user_id'), nullable=True, unique=None, default=None)
     _email = Column("email", String(255), nullable=True, unique=False, default=None)
     user = relationship('User', lazy='joined')
 
     @validates('_email')
     def validate_email(self, key, email):
         # check if this email is not main one
         main_email = Session().query(User).filter(User.email == email).scalar()
         if main_email is not None:
             raise AttributeError('email %s is present is user table' % email)
         return email
 
     @hybrid_property
     def email(self):
         return self._email
 
     @email.setter
     def email(self, val):
         self._email = val.lower() if val else None
 
 
 class UserIpMap(Base, BaseModel):
     __tablename__ = 'user_ip_map'
     __table_args__ = (
         UniqueConstraint('user_id', 'ip_addr'),
         base_table_args
     )
     __mapper_args__ = {}
 
     ip_id = Column("ip_id", Integer(), nullable=False, unique=True, default=None, primary_key=True)
     user_id = Column("user_id", Integer(), ForeignKey('users.user_id'), nullable=True, unique=None, default=None)
     ip_addr = Column("ip_addr", String(255), nullable=True, unique=False, default=None)
     active = Column("active", Boolean(), nullable=True, unique=None, default=True)
     description = Column("description", String(10000), nullable=True, unique=None, default=None)
     user = relationship('User', lazy='joined')
 
     @hybrid_property
     def description_safe(self):
         from rhodecode.lib import helpers as h
         return h.escape(self.description)
 
     @classmethod
     def _get_ip_range(cls, ip_addr):
         net = ipaddress.ip_network(safe_unicode(ip_addr), strict=False)
         return [str(net.network_address), str(net.broadcast_address)]
 
     def __json__(self):
         return {
           'ip_addr': self.ip_addr,
           'ip_range': self._get_ip_range(self.ip_addr),
         }
 
     def __unicode__(self):
         return u"<%s('user_id:%s=>%s')>" % (self.__class__.__name__,
                                             self.user_id, self.ip_addr)
 
 
 class UserSshKeys(Base, BaseModel):
     __tablename__ = 'user_ssh_keys'
     __table_args__ = (
         Index('usk_ssh_key_fingerprint_idx', 'ssh_key_fingerprint'),
 
         UniqueConstraint('ssh_key_fingerprint'),
 
         base_table_args
     )
     __mapper_args__ = {}
 
     ssh_key_id = Column('ssh_key_id', Integer(), nullable=False, unique=True, default=None, primary_key=True)
     ssh_key_data = Column('ssh_key_data', String(10240), nullable=False, unique=None, default=None)
     ssh_key_fingerprint = Column('ssh_key_fingerprint', String(255), nullable=False, unique=None, default=None)
 
     description = Column('description', UnicodeText().with_variant(UnicodeText(1024), 'mysql'))
 
     created_on = Column('created_on', DateTime(timezone=False), nullable=False, default=datetime.datetime.now)
     accessed_on = Column('accessed_on', DateTime(timezone=False), nullable=True, default=None)
     user_id = Column('user_id', Integer(), ForeignKey('users.user_id'), nullable=True, unique=None, default=None)
 
     user = relationship('User', lazy='joined')
 
     def __json__(self):
         data = {
             'ssh_fingerprint': self.ssh_key_fingerprint,
             'description': self.description,
             'created_on': self.created_on
         }
         return data
 
     def get_api_data(self):
         data = self.__json__()
         return data
 
 
 class UserLog(Base, BaseModel):
     __tablename__ = 'user_logs'
     __table_args__ = (
         base_table_args,
     )
 
     VERSION_1 = 'v1'
     VERSION_2 = 'v2'
     VERSIONS = [VERSION_1, VERSION_2]
 
     user_log_id = Column("user_log_id", Integer(), nullable=False, unique=True, default=None, primary_key=True)
     user_id = Column("user_id", Integer(), ForeignKey('users.user_id',ondelete='SET NULL'), nullable=True, unique=None, default=None)
     username = Column("username", String(255), nullable=True, unique=None, default=None)
     repository_id = Column("repository_id", Integer(), ForeignKey('repositories.repo_id', ondelete='SET NULL'), nullable=True, unique=None, default=None)
     repository_name = Column("repository_name", String(255), nullable=True, unique=None, default=None)
     user_ip = Column("user_ip", String(255), nullable=True, unique=None, default=None)
     action = Column("action", Text().with_variant(Text(1200000), 'mysql'), nullable=True, unique=None, default=None)
     action_date = Column("action_date", DateTime(timezone=False), nullable=True, unique=None, default=None)
 
     version = Column("version", String(255), nullable=True, default=VERSION_1)
     user_data = Column('user_data_json', MutationObj.as_mutable(JsonType(dialect_map=dict(mysql=LONGTEXT()))))
     action_data = Column('action_data_json', MutationObj.as_mutable(JsonType(dialect_map=dict(mysql=LONGTEXT()))))
 
     def __unicode__(self):
         return u"<%s('id:%s:%s')>" % (
             self.__class__.__name__, self.repository_name, self.action)
 
     def __json__(self):
         return {
             'user_id': self.user_id,
             'username': self.username,
             'repository_id': self.repository_id,
             'repository_name': self.repository_name,
             'user_ip': self.user_ip,
             'action_date': self.action_date,
             'action': self.action,
         }
 
     @hybrid_property
     def entry_id(self):
         return self.user_log_id
 
     @property
     def action_as_day(self):
         return datetime.date(*self.action_date.timetuple()[:3])
 
     user = relationship('User')
     repository = relationship('Repository', cascade='')
 
 
 class UserGroup(Base, BaseModel):
     __tablename__ = 'users_groups'
     __table_args__ = (
         base_table_args,
     )
 
     users_group_id = Column("users_group_id", Integer(), nullable=False, unique=True, default=None, primary_key=True)
     users_group_name = Column("users_group_name", String(255), nullable=False, unique=True, default=None)
     user_group_description = Column("user_group_description", String(10000), nullable=True, unique=None, default=None)
     users_group_active = Column("users_group_active", Boolean(), nullable=True, unique=None, default=None)
     inherit_default_permissions = Column("users_group_inherit_default_permissions", Boolean(), nullable=False, unique=None, default=True)
     user_id = Column("user_id", Integer(), ForeignKey('users.user_id'), nullable=False, unique=False, default=None)
     created_on = Column('created_on', DateTime(timezone=False), nullable=False, default=datetime.datetime.now)
     _group_data = Column("group_data", LargeBinary(), nullable=True)  # JSON data
 
     members = relationship('UserGroupMember', cascade="all, delete-orphan", lazy="joined")
     users_group_to_perm = relationship('UserGroupToPerm', cascade='all')
     users_group_repo_to_perm = relationship('UserGroupRepoToPerm', cascade='all')
     users_group_repo_group_to_perm = relationship('UserGroupRepoGroupToPerm', cascade='all')
     user_user_group_to_perm = relationship('UserUserGroupToPerm', cascade='all')
     user_group_user_group_to_perm = relationship('UserGroupUserGroupToPerm ', primaryjoin="UserGroupUserGroupToPerm.target_user_group_id==UserGroup.users_group_id", cascade='all')
 
     user_group_review_rules = relationship('RepoReviewRuleUserGroup', cascade='all')
     user = relationship('User', primaryjoin="User.user_id==UserGroup.user_id")
 
     @classmethod
     def _load_group_data(cls, column):
         if not column:
             return {}
 
         try:
             return json.loads(column) or {}
         except TypeError:
             return {}
 
     @hybrid_property
     def description_safe(self):
         from rhodecode.lib import helpers as h
         return h.escape(self.user_group_description)
 
     @hybrid_property
     def group_data(self):
         return self._load_group_data(self._group_data)
 
     @group_data.expression
     def group_data(self, **kwargs):
         return self._group_data
 
     @group_data.setter
     def group_data(self, val):
         try:
             self._group_data = json.dumps(val)
         except Exception:
             log.error(traceback.format_exc())
 
     @classmethod
     def _load_sync(cls, group_data):
         if group_data:
             return group_data.get('extern_type')
 
     @property
     def sync(self):
         return self._load_sync(self.group_data)
 
     def __unicode__(self):
         return u"<%s('id:%s:%s')>" % (self.__class__.__name__,
                                       self.users_group_id,
                                       self.users_group_name)
 
     @classmethod
     def get_by_group_name(cls, group_name, cache=False,
                           case_insensitive=False):
         if case_insensitive:
             q = cls.query().filter(func.lower(cls.users_group_name) ==
                                    func.lower(group_name))
 
         else:
             q = cls.query().filter(cls.users_group_name == group_name)
         if cache:
             q = q.options(
                 FromCache("sql_cache_short", "get_group_%s" % _hash_key(group_name)))
         return q.scalar()
 
     @classmethod
     def get(cls, user_group_id, cache=False):
         if not user_group_id:
             return
 
         user_group = cls.query()
         if cache:
             user_group = user_group.options(
                 FromCache("sql_cache_short", "get_users_group_%s" % user_group_id))
         return user_group.get(user_group_id)
 
     def permissions(self, with_admins=True, with_owner=True,
                     expand_from_user_groups=False):
         """
         Permissions for user groups
         """
         _admin_perm = 'usergroup.admin'
 
         owner_row = []
         if with_owner:
             usr = AttributeDict(self.user.get_dict())
             usr.owner_row = True
             usr.permission = _admin_perm
             owner_row.append(usr)
 
         super_admin_ids = []
         super_admin_rows = []
         if with_admins:
             for usr in User.get_all_super_admins():
                 super_admin_ids.append(usr.user_id)
                 # if this admin is also owner, don't double the record
                 if usr.user_id == owner_row[0].user_id:
                     owner_row[0].admin_row = True
                 else:
                     usr = AttributeDict(usr.get_dict())
                     usr.admin_row = True
                     usr.permission = _admin_perm
                     super_admin_rows.append(usr)
 
         q = UserUserGroupToPerm.query().filter(UserUserGroupToPerm.user_group == self)
         q = q.options(joinedload(UserUserGroupToPerm.user_group),
                       joinedload(UserUserGroupToPerm.user),
                       joinedload(UserUserGroupToPerm.permission),)
 
         # get owners and admins and permissions. We do a trick of re-writing
         # objects from sqlalchemy to named-tuples due to sqlalchemy session
         # has a global reference and changing one object propagates to all
         # others. This means if admin is also an owner admin_row that change
         # would propagate to both objects
         perm_rows = []
         for _usr in q.all():
             usr = AttributeDict(_usr.user.get_dict())
             # if this user is also owner/admin, mark as duplicate record
             if usr.user_id == owner_row[0].user_id or usr.user_id in super_admin_ids:
                 usr.duplicate_perm = True
             usr.permission = _usr.permission.permission_name
             perm_rows.append(usr)
 
         # filter the perm rows by 'default' first and then sort them by
         # admin,write,read,none permissions sorted again alphabetically in
         # each group
         perm_rows = sorted(perm_rows, key=display_user_sort)
 
         user_groups_rows = []
         if expand_from_user_groups:
             for ug in self.permission_user_groups(with_members=True):
                 for user_data in ug.members:
                     user_groups_rows.append(user_data)
 
         return super_admin_rows + owner_row + perm_rows + user_groups_rows
 
     def permission_user_groups(self, with_members=False):
         q = UserGroupUserGroupToPerm.query()\
             .filter(UserGroupUserGroupToPerm.target_user_group == self)
         q = q.options(joinedload(UserGroupUserGroupToPerm.user_group),
                       joinedload(UserGroupUserGroupToPerm.target_user_group),
                       joinedload(UserGroupUserGroupToPerm.permission),)
 
         perm_rows = []
         for _user_group in q.all():
             entry = AttributeDict(_user_group.user_group.get_dict())
             entry.permission = _user_group.permission.permission_name
             if with_members:
                 entry.members = [x.user.get_dict()
                                  for x in _user_group.user_group.members]
             perm_rows.append(entry)
 
         perm_rows = sorted(perm_rows, key=display_user_group_sort)
         return perm_rows
 
     def _get_default_perms(self, user_group, suffix=''):
         from rhodecode.model.permission import PermissionModel
         return PermissionModel().get_default_perms(user_group.users_group_to_perm, suffix)
 
     def get_default_perms(self, suffix=''):
         return self._get_default_perms(self, suffix)
 
     def get_api_data(self, with_group_members=True, include_secrets=False):
         """
         :param include_secrets: See :meth:`User.get_api_data`, this parameter is
            basically forwarded.
 
         """
         user_group = self
         data = {
             'users_group_id': user_group.users_group_id,
             'group_name': user_group.users_group_name,
             'group_description': user_group.user_group_description,
             'active': user_group.users_group_active,
             'owner': user_group.user.username,
             'sync': user_group.sync,
             'owner_email': user_group.user.email,
         }
 
         if with_group_members:
             users = []
             for user in user_group.members:
                 user = user.user
                 users.append(user.get_api_data(include_secrets=include_secrets))
             data['users'] = users
 
         return data
 
 
 class UserGroupMember(Base, BaseModel):
     __tablename__ = 'users_groups_members'
     __table_args__ = (
         base_table_args,
     )
 
     users_group_member_id = Column("users_group_member_id", Integer(), nullable=False, unique=True, default=None, primary_key=True)
     users_group_id = Column("users_group_id", Integer(), ForeignKey('users_groups.users_group_id'), nullable=False, unique=None, default=None)
     user_id = Column("user_id", Integer(), ForeignKey('users.user_id'), nullable=False, unique=None, default=None)
 
     user = relationship('User', lazy='joined')
     users_group = relationship('UserGroup')
 
     def __init__(self, gr_id='', u_id=''):
         self.users_group_id = gr_id
         self.user_id = u_id
 
 
 class RepositoryField(Base, BaseModel):
     __tablename__ = 'repositories_fields'
     __table_args__ = (
         UniqueConstraint('repository_id', 'field_key'),  # no-multi field
         base_table_args,
     )
 
     PREFIX = 'ex_'  # prefix used in form to not conflict with already existing fields
 
     repo_field_id = Column("repo_field_id", Integer(), nullable=False, unique=True, default=None, primary_key=True)
     repository_id = Column("repository_id", Integer(), ForeignKey('repositories.repo_id'), nullable=False, unique=None, default=None)
     field_key = Column("field_key", String(250))
     field_label = Column("field_label", String(1024), nullable=False)
     field_value = Column("field_value", String(10000), nullable=False)
     field_desc = Column("field_desc", String(1024), nullable=False)
     field_type = Column("field_type", String(255), nullable=False, unique=None)
     created_on = Column('created_on', DateTime(timezone=False), nullable=False, default=datetime.datetime.now)
 
     repository = relationship('Repository')
 
     @property
     def field_key_prefixed(self):
         return 'ex_%s' % self.field_key
 
     @classmethod
     def un_prefix_key(cls, key):
         if key.startswith(cls.PREFIX):
             return key[len(cls.PREFIX):]
         return key
 
     @classmethod
     def get_by_key_name(cls, key, repo):
         row = cls.query()\
                 .filter(cls.repository == repo)\
                 .filter(cls.field_key == key).scalar()
         return row
 
 
 class Repository(Base, BaseModel):
     __tablename__ = 'repositories'
     __table_args__ = (
         Index('r_repo_name_idx', 'repo_name', mysql_length=255),
         base_table_args,
     )
     DEFAULT_CLONE_URI = '{scheme}://{user}@{netloc}/{repo}'
     DEFAULT_CLONE_URI_ID = '{scheme}://{user}@{netloc}/_{repoid}'
     DEFAULT_CLONE_URI_SSH = 'ssh://{sys_user}@{hostname}/{repo}'
 
     STATE_CREATED = 'repo_state_created'
     STATE_PENDING = 'repo_state_pending'
     STATE_ERROR = 'repo_state_error'
 
     LOCK_AUTOMATIC = 'lock_auto'
     LOCK_API = 'lock_api'
     LOCK_WEB = 'lock_web'
     LOCK_PULL = 'lock_pull'
 
     NAME_SEP = URL_SEP
 
     repo_id = Column(
         "repo_id", Integer(), nullable=False, unique=True, default=None,
         primary_key=True)
     _repo_name = Column(
         "repo_name", Text(), nullable=False, default=None)
     repo_name_hash = Column(
         "repo_name_hash", String(255), nullable=False, unique=True)
     repo_state = Column("repo_state", String(255), nullable=True)
 
     clone_uri = Column(
         "clone_uri", EncryptedTextValue(), nullable=True, unique=False,
         default=None)
     push_uri = Column(
         "push_uri", EncryptedTextValue(), nullable=True, unique=False,
         default=None)
     repo_type = Column(
         "repo_type", String(255), nullable=False, unique=False, default=None)
     user_id = Column(
         "user_id", Integer(), ForeignKey('users.user_id'), nullable=False,
         unique=False, default=None)
     private = Column(
         "private", Boolean(), nullable=True, unique=None, default=None)
     archived = Column(
         "archived", Boolean(), nullable=True, unique=None, default=None)
     enable_statistics = Column(
         "statistics", Boolean(), nullable=True, unique=None, default=True)
     enable_downloads = Column(
         "downloads", Boolean(), nullable=True, unique=None, default=True)
     description = Column(
         "description", String(10000), nullable=True, unique=None, default=None)
     created_on = Column(
         'created_on', DateTime(timezone=False), nullable=True, unique=None,
         default=datetime.datetime.now)
     updated_on = Column(
         'updated_on', DateTime(timezone=False), nullable=True, unique=None,
         default=datetime.datetime.now)
     _landing_revision = Column(
         "landing_revision", String(255), nullable=False, unique=False,
         default=None)
     enable_locking = Column(
         "enable_locking", Boolean(), nullable=False, unique=None,
         default=False)
     _locked = Column(
         "locked", String(255), nullable=True, unique=False, default=None)
     _changeset_cache = Column(
         "changeset_cache", LargeBinary(), nullable=True)  # JSON data
 
     fork_id = Column(
         "fork_id", Integer(), ForeignKey('repositories.repo_id'),
         nullable=True, unique=False, default=None)
     group_id = Column(
         "group_id", Integer(), ForeignKey('groups.group_id'), nullable=True,
         unique=False, default=None)
 
     user = relationship('User', lazy='joined')
     fork = relationship('Repository', remote_side=repo_id, lazy='joined')
     group = relationship('RepoGroup', lazy='joined')
     repo_to_perm = relationship(
         'UserRepoToPerm', cascade='all',
         order_by='UserRepoToPerm.repo_to_perm_id')
     users_group_to_perm = relationship('UserGroupRepoToPerm', cascade='all')
     stats = relationship('Statistics', cascade='all', uselist=False)
 
     followers = relationship(
         'UserFollowing',
         primaryjoin='UserFollowing.follows_repo_id==Repository.repo_id',
         cascade='all')
     extra_fields = relationship(
         'RepositoryField', cascade="all, delete-orphan")
     logs = relationship('UserLog')
     comments = relationship(
         'ChangesetComment', cascade="all, delete-orphan")
     pull_requests_source = relationship(
         'PullRequest',
         primaryjoin='PullRequest.source_repo_id==Repository.repo_id',
         cascade="all, delete-orphan")
     pull_requests_target = relationship(
         'PullRequest',
         primaryjoin='PullRequest.target_repo_id==Repository.repo_id',
         cascade="all, delete-orphan")
     ui = relationship('RepoRhodeCodeUi', cascade="all")
     settings = relationship('RepoRhodeCodeSetting', cascade="all")
     integrations = relationship('Integration', cascade="all, delete-orphan")
 
     scoped_tokens = relationship('UserApiKeys', cascade="all")
 
     # no cascade, set NULL
     artifacts = relationship('FileStore', primaryjoin='FileStore.scope_repo_id==Repository.repo_id')
 
     def __unicode__(self):
         return u"<%s('%s:%s')>" % (self.__class__.__name__, self.repo_id,
                                    safe_unicode(self.repo_name))
 
     @hybrid_property
     def description_safe(self):
         from rhodecode.lib import helpers as h
         return h.escape(self.description)
 
     @hybrid_property
     def landing_rev(self):
         # always should return [rev_type, rev], e.g ['branch', 'master']
         if self._landing_revision:
             _rev_info = self._landing_revision.split(':')
             if len(_rev_info) < 2:
                 _rev_info.insert(0, 'rev')
             return [_rev_info[0], _rev_info[1]]
         return [None, None]
 
     @property
     def landing_ref_type(self):
         return self.landing_rev[0]
 
     @property
     def landing_ref_name(self):
         return self.landing_rev[1]
 
     @landing_rev.setter
     def landing_rev(self, val):
         if ':' not in val:
             raise ValueError('value must be delimited with `:` and consist '
                              'of <rev_type>:<rev>, got %s instead' % val)
         self._landing_revision = val
 
     @hybrid_property
     def locked(self):
         if self._locked:
             user_id, timelocked, reason = self._locked.split(':')
             lock_values = int(user_id), timelocked, reason
         else:
             lock_values = [None, None, None]
         return lock_values
 
     @locked.setter
     def locked(self, val):
         if val and isinstance(val, (list, tuple)):
             self._locked = ':'.join(map(str, val))
         else:
             self._locked = None
 
     @classmethod
     def _load_changeset_cache(cls, repo_id, changeset_cache_raw):
         from rhodecode.lib.vcs.backends.base import EmptyCommit
         dummy = EmptyCommit().__json__()
         if not changeset_cache_raw:
             dummy['source_repo_id'] = repo_id
             return json.loads(json.dumps(dummy))
 
         try:
             return json.loads(changeset_cache_raw)
         except TypeError:
             return dummy
         except Exception:
             log.error(traceback.format_exc())
             return dummy
 
     @hybrid_property
     def changeset_cache(self):
         return self._load_changeset_cache(self.repo_id, self._changeset_cache)
 
     @changeset_cache.setter
     def changeset_cache(self, val):
         try:
             self._changeset_cache = json.dumps(val)
         except Exception:
             log.error(traceback.format_exc())
 
     @hybrid_property
     def repo_name(self):
         return self._repo_name
 
     @repo_name.setter
     def repo_name(self, value):
         self._repo_name = value
         self.repo_name_hash = hashlib.sha1(safe_str(value)).hexdigest()
 
     @classmethod
     def normalize_repo_name(cls, repo_name):
         """
         Normalizes os specific repo_name to the format internally stored inside
         database using URL_SEP
 
         :param cls:
         :param repo_name:
         """
         return cls.NAME_SEP.join(repo_name.split(os.sep))
 
     @classmethod
     def get_by_repo_name(cls, repo_name, cache=False, identity_cache=False):
         session = Session()
         q = session.query(cls).filter(cls.repo_name == repo_name)
 
         if cache:
             if identity_cache:
                 val = cls.identity_cache(session, 'repo_name', repo_name)
                 if val:
                     return val
             else:
                 cache_key = "get_repo_by_name_%s" % _hash_key(repo_name)
                 q = q.options(
                     FromCache("sql_cache_short", cache_key))
 
         return q.scalar()
 
     @classmethod
     def get_by_id_or_repo_name(cls, repoid):
         if isinstance(repoid, (int, long)):
             try:
                 repo = cls.get(repoid)
             except ValueError:
                 repo = None
         else:
             repo = cls.get_by_repo_name(repoid)
         return repo
 
     @classmethod
     def get_by_full_path(cls, repo_full_path):
         repo_name = repo_full_path.split(cls.base_path(), 1)[-1]
         repo_name = cls.normalize_repo_name(repo_name)
         return cls.get_by_repo_name(repo_name.strip(URL_SEP))
 
     @classmethod
     def get_repo_forks(cls, repo_id):
         return cls.query().filter(Repository.fork_id == repo_id)
 
     @classmethod
     def base_path(cls):
         """
         Returns base path when all repos are stored
 
         :param cls:
         """
         q = Session().query(RhodeCodeUi)\
             .filter(RhodeCodeUi.ui_key == cls.NAME_SEP)
         q = q.options(FromCache("sql_cache_short", "repository_repo_path"))
         return q.one().ui_value
 
     @classmethod
     def get_all_repos(cls, user_id=Optional(None), group_id=Optional(None),
                       case_insensitive=True, archived=False):
         q = Repository.query()
 
         if not archived:
             q = q.filter(Repository.archived.isnot(true()))
 
         if not isinstance(user_id, Optional):
             q = q.filter(Repository.user_id == user_id)
 
         if not isinstance(group_id, Optional):
             q = q.filter(Repository.group_id == group_id)
 
         if case_insensitive:
             q = q.order_by(func.lower(Repository.repo_name))
         else:
             q = q.order_by(Repository.repo_name)
 
         return q.all()
 
     @property
     def repo_uid(self):
         return '_{}'.format(self.repo_id)
 
     @property
     def forks(self):
         """
         Return forks of this repo
         """
         return Repository.get_repo_forks(self.repo_id)
 
     @property
     def parent(self):
         """
         Returns fork parent
         """
         return self.fork
 
     @property
     def just_name(self):
         return self.repo_name.split(self.NAME_SEP)[-1]
 
     @property
     def groups_with_parents(self):
         groups = []
         if self.group is None:
             return groups
 
         cur_gr = self.group
         groups.insert(0, cur_gr)
         while 1:
             gr = getattr(cur_gr, 'parent_group', None)
             cur_gr = cur_gr.parent_group
             if gr is None:
                 break
             groups.insert(0, gr)
 
         return groups
 
     @property
     def groups_and_repo(self):
         return self.groups_with_parents, self
 
     @LazyProperty
     def repo_path(self):
         """
         Returns base full path for that repository means where it actually
         exists on a filesystem
         """
         q = Session().query(RhodeCodeUi).filter(
             RhodeCodeUi.ui_key == self.NAME_SEP)
         q = q.options(FromCache("sql_cache_short", "repository_repo_path"))
         return q.one().ui_value
 
     @property
     def repo_full_path(self):
         p = [self.repo_path]
         # we need to split the name by / since this is how we store the
         # names in the database, but that eventually needs to be converted
         # into a valid system path
         p += self.repo_name.split(self.NAME_SEP)
         return os.path.join(*map(safe_unicode, p))
 
     @property
     def cache_keys(self):
         """
         Returns associated cache keys for that repo
         """
         invalidation_namespace = CacheKey.REPO_INVALIDATION_NAMESPACE.format(
             repo_id=self.repo_id)
         return CacheKey.query()\
             .filter(CacheKey.cache_args == invalidation_namespace)\
             .order_by(CacheKey.cache_key)\
             .all()
 
     @property
     def cached_diffs_relative_dir(self):
         """
         Return a relative to the repository store path of cached diffs
         used for safe display for users, who shouldn't know the absolute store
         path
         """
         return os.path.join(
             os.path.dirname(self.repo_name),
             self.cached_diffs_dir.split(os.path.sep)[-1])
 
     @property
     def cached_diffs_dir(self):
         path = self.repo_full_path
         return os.path.join(
             os.path.dirname(path),
             '.__shadow_diff_cache_repo_{}'.format(self.repo_id))
 
     def cached_diffs(self):
         diff_cache_dir = self.cached_diffs_dir
         if os.path.isdir(diff_cache_dir):
             return os.listdir(diff_cache_dir)
         return []
 
     def shadow_repos(self):
         shadow_repos_pattern = '.__shadow_repo_{}'.format(self.repo_id)
         return [
             x for x in os.listdir(os.path.dirname(self.repo_full_path))
             if x.startswith(shadow_repos_pattern)]
 
     def get_new_name(self, repo_name):
         """
         returns new full repository name based on assigned group and new new
 
         :param group_name:
         """
         path_prefix = self.group.full_path_splitted if self.group else []
         return self.NAME_SEP.join(path_prefix + [repo_name])
 
     @property
     def _config(self):
         """
         Returns db based config object.
         """
         from rhodecode.lib.utils import make_db_config
         return make_db_config(clear_session=False, repo=self)
 
     def permissions(self, with_admins=True, with_owner=True,
                     expand_from_user_groups=False):
         """
         Permissions for repositories
         """
         _admin_perm = 'repository.admin'
 
         owner_row = []
         if with_owner:
             usr = AttributeDict(self.user.get_dict())
             usr.owner_row = True
             usr.permission = _admin_perm
             usr.permission_id = None
             owner_row.append(usr)
 
         super_admin_ids = []
         super_admin_rows = []
         if with_admins:
             for usr in User.get_all_super_admins():
                 super_admin_ids.append(usr.user_id)
                 # if this admin is also owner, don't double the record
                 if usr.user_id == owner_row[0].user_id:
                     owner_row[0].admin_row = True
                 else:
                     usr = AttributeDict(usr.get_dict())
                     usr.admin_row = True
                     usr.permission = _admin_perm
                     usr.permission_id = None
                     super_admin_rows.append(usr)
 
         q = UserRepoToPerm.query().filter(UserRepoToPerm.repository == self)
         q = q.options(joinedload(UserRepoToPerm.repository),
                       joinedload(UserRepoToPerm.user),
                       joinedload(UserRepoToPerm.permission),)
 
         # get owners and admins and permissions. We do a trick of re-writing
         # objects from sqlalchemy to named-tuples due to sqlalchemy session
         # has a global reference and changing one object propagates to all
         # others. This means if admin is also an owner admin_row that change
         # would propagate to both objects
         perm_rows = []
         for _usr in q.all():
             usr = AttributeDict(_usr.user.get_dict())
             # if this user is also owner/admin, mark as duplicate record
             if usr.user_id == owner_row[0].user_id or usr.user_id in super_admin_ids:
                 usr.duplicate_perm = True
             # also check if this permission is maybe used by branch_permissions
             if _usr.branch_perm_entry:
                 usr.branch_rules = [x.branch_rule_id for x in _usr.branch_perm_entry]
 
             usr.permission = _usr.permission.permission_name
             usr.permission_id = _usr.repo_to_perm_id
             perm_rows.append(usr)
 
         # filter the perm rows by 'default' first and then sort them by
         # admin,write,read,none permissions sorted again alphabetically in
         # each group
         perm_rows = sorted(perm_rows, key=display_user_sort)
 
         user_groups_rows = []
         if expand_from_user_groups:
             for ug in self.permission_user_groups(with_members=True):
                 for user_data in ug.members:
                     user_groups_rows.append(user_data)
 
         return super_admin_rows + owner_row + perm_rows + user_groups_rows
 
     def permission_user_groups(self, with_members=True):
         q = UserGroupRepoToPerm.query()\
             .filter(UserGroupRepoToPerm.repository == self)
         q = q.options(joinedload(UserGroupRepoToPerm.repository),
                       joinedload(UserGroupRepoToPerm.users_group),
                       joinedload(UserGroupRepoToPerm.permission),)
 
         perm_rows = []
         for _user_group in q.all():
             entry = AttributeDict(_user_group.users_group.get_dict())
             entry.permission = _user_group.permission.permission_name
             if with_members:
                 entry.members = [x.user.get_dict()
                                  for x in _user_group.users_group.members]
             perm_rows.append(entry)
 
         perm_rows = sorted(perm_rows, key=display_user_group_sort)
         return perm_rows
 
     def get_api_data(self, include_secrets=False):
         """
         Common function for generating repo api data
 
         :param include_secrets: See :meth:`User.get_api_data`.
 
         """
         # TODO: mikhail: Here there is an anti-pattern, we probably need to
         # move this methods on models level.
         from rhodecode.model.settings import SettingsModel
         from rhodecode.model.repo import RepoModel
 
         repo = self
         _user_id, _time, _reason = self.locked
 
         data = {
             'repo_id': repo.repo_id,
             'repo_name': repo.repo_name,
             'repo_type': repo.repo_type,
             'clone_uri': repo.clone_uri or '',
             'push_uri': repo.push_uri or '',
             'url': RepoModel().get_url(self),
             'private': repo.private,
             'created_on': repo.created_on,
             'description': repo.description_safe,
             'landing_rev': repo.landing_rev,
             'owner': repo.user.username,
             'fork_of': repo.fork.repo_name if repo.fork else None,
             'fork_of_id': repo.fork.repo_id if repo.fork else None,
             'enable_statistics': repo.enable_statistics,
             'enable_locking': repo.enable_locking,
             'enable_downloads': repo.enable_downloads,
             'last_changeset': repo.changeset_cache,
             'locked_by': User.get(_user_id).get_api_data(
                 include_secrets=include_secrets) if _user_id else None,
             'locked_date': time_to_datetime(_time) if _time else None,
             'lock_reason': _reason if _reason else None,
         }
 
         # TODO: mikhail: should be per-repo settings here
         rc_config = SettingsModel().get_all_settings()
         repository_fields = str2bool(
             rc_config.get('rhodecode_repository_fields'))
         if repository_fields:
             for f in self.extra_fields:
                 data[f.field_key_prefixed] = f.field_value
 
         return data
 
     @classmethod
     def lock(cls, repo, user_id, lock_time=None, lock_reason=None):
         if not lock_time:
             lock_time = time.time()
         if not lock_reason:
             lock_reason = cls.LOCK_AUTOMATIC
         repo.locked = [user_id, lock_time, lock_reason]
         Session().add(repo)
         Session().commit()
 
     @classmethod
     def unlock(cls, repo):
         repo.locked = None
         Session().add(repo)
         Session().commit()
 
     @classmethod
     def getlock(cls, repo):
         return repo.locked
 
     def is_user_lock(self, user_id):
         if self.lock[0]:
             lock_user_id = safe_int(self.lock[0])
             user_id = safe_int(user_id)
             # both are ints, and they are equal
             return all([lock_user_id, user_id]) and lock_user_id == user_id
 
         return False
 
     def get_locking_state(self, action, user_id, only_when_enabled=True):
         """
         Checks locking on this repository, if locking is enabled and lock is
         present returns a tuple of make_lock, locked, locked_by.
         make_lock can have 3 states None (do nothing) True, make lock
         False release lock, This value is later propagated to hooks, which
         do the locking. Think about this as signals passed to hooks what to do.
 
         """
         # TODO: johbo: This is part of the business logic and should be moved
         # into the RepositoryModel.
 
         if action not in ('push', 'pull'):
             raise ValueError("Invalid action value: %s" % repr(action))
 
         # defines if locked error should be thrown to user
         currently_locked = False
         # defines if new lock should be made, tri-state
         make_lock = None
         repo = self
         user = User.get(user_id)
 
         lock_info = repo.locked
 
         if repo and (repo.enable_locking or not only_when_enabled):
             if action == 'push':
                 # check if it's already locked !, if it is compare users
                 locked_by_user_id = lock_info[0]
                 if user.user_id == locked_by_user_id:
                     log.debug(
                         'Got `push` action from user %s, now unlocking', user)
                     # unlock if we have push from user who locked
                     make_lock = False
                 else:
                     # we're not the same user who locked, ban with
                     # code defined in settings (default is 423 HTTP Locked) !
                     log.debug('Repo %s is currently locked by %s', repo, user)
                     currently_locked = True
             elif action == 'pull':
                 # [0] user [1] date
                 if lock_info[0] and lock_info[1]:
                     log.debug('Repo %s is currently locked by %s', repo, user)
                     currently_locked = True
                 else:
                     log.debug('Setting lock on repo %s by %s', repo, user)
                     make_lock = True
 
         else:
             log.debug('Repository %s do not have locking enabled', repo)
 
         log.debug('FINAL locking values make_lock:%s,locked:%s,locked_by:%s',
                   make_lock, currently_locked, lock_info)
 
         from rhodecode.lib.auth import HasRepoPermissionAny
         perm_check = HasRepoPermissionAny('repository.write', 'repository.admin')
         if make_lock and not perm_check(repo_name=repo.repo_name, user=user):
             # if we don't have at least write permission we cannot make a lock
             log.debug('lock state reset back to FALSE due to lack '
                       'of at least read permission')
             make_lock = False
 
         return make_lock, currently_locked, lock_info
 
     @property
     def last_commit_cache_update_diff(self):
         return time.time() - (safe_int(self.changeset_cache.get('updated_on')) or 0)
 
     @classmethod
     def _load_commit_change(cls, last_commit_cache):
         from rhodecode.lib.vcs.utils.helpers import parse_datetime
         empty_date = datetime.datetime.fromtimestamp(0)
         date_latest = last_commit_cache.get('date', empty_date)
         try:
             return parse_datetime(date_latest)
         except Exception:
             return empty_date
 
     @property
     def last_commit_change(self):
         return self._load_commit_change(self.changeset_cache)
 
     @property
     def last_db_change(self):
         return self.updated_on
 
     @property
     def clone_uri_hidden(self):
         clone_uri = self.clone_uri
         if clone_uri:
             import urlobject
             url_obj = urlobject.URLObject(cleaned_uri(clone_uri))
             if url_obj.password:
                 clone_uri = url_obj.with_password('*****')
         return clone_uri
 
     @property
     def push_uri_hidden(self):
         push_uri = self.push_uri
         if push_uri:
             import urlobject
             url_obj = urlobject.URLObject(cleaned_uri(push_uri))
             if url_obj.password:
                 push_uri = url_obj.with_password('*****')
         return push_uri
 
     def clone_url(self, **override):
         from rhodecode.model.settings import SettingsModel
 
         uri_tmpl = None
         if 'with_id' in override:
             uri_tmpl = self.DEFAULT_CLONE_URI_ID
             del override['with_id']
 
         if 'uri_tmpl' in override:
             uri_tmpl = override['uri_tmpl']
             del override['uri_tmpl']
 
         ssh = False
         if 'ssh' in override:
             ssh = True
             del override['ssh']
 
         # we didn't override our tmpl from **overrides
         request = get_current_request()
         if not uri_tmpl:
             if hasattr(request, 'call_context') and hasattr(request.call_context, 'rc_config'):
                 rc_config = request.call_context.rc_config
             else:
                 rc_config = SettingsModel().get_all_settings(cache=True)
 
             if ssh:
                 uri_tmpl = rc_config.get(
                     'rhodecode_clone_uri_ssh_tmpl') or self.DEFAULT_CLONE_URI_SSH
 
             else:
                 uri_tmpl = rc_config.get(
                     'rhodecode_clone_uri_tmpl') or self.DEFAULT_CLONE_URI
 
         return get_clone_url(request=request,
                              uri_tmpl=uri_tmpl,
                              repo_name=self.repo_name,
                              repo_id=self.repo_id,
                              repo_type=self.repo_type,
                              **override)
 
     def set_state(self, state):
         self.repo_state = state
         Session().add(self)
     #==========================================================================
     # SCM PROPERTIES
     #==========================================================================
 
     def get_commit(self, commit_id=None, commit_idx=None, pre_load=None, maybe_unreachable=False):
         return get_commit_safe(
             self.scm_instance(), commit_id, commit_idx, pre_load=pre_load,
             maybe_unreachable=maybe_unreachable)
 
     def get_changeset(self, rev=None, pre_load=None):
         warnings.warn("Use get_commit", DeprecationWarning)
         commit_id = None
         commit_idx = None
         if isinstance(rev, compat.string_types):
             commit_id = rev
         else:
             commit_idx = rev
         return self.get_commit(commit_id=commit_id, commit_idx=commit_idx,
                                pre_load=pre_load)
 
     def get_landing_commit(self):
         """
         Returns landing commit, or if that doesn't exist returns the tip
         """
         _rev_type, _rev = self.landing_rev
         commit = self.get_commit(_rev)
         if isinstance(commit, EmptyCommit):
             return self.get_commit()
         return commit
 
     def flush_commit_cache(self):
         self.update_commit_cache(cs_cache={'raw_id':'0'})
         self.update_commit_cache()
 
     def update_commit_cache(self, cs_cache=None, config=None):
         """
         Update cache of last commit for repository
         cache_keys should be::
 
             source_repo_id
             short_id
             raw_id
             revision
             parents
             message
             date
             author
             updated_on
 
         """
         from rhodecode.lib.vcs.backends.base import BaseChangeset
         from rhodecode.lib.vcs.utils.helpers import parse_datetime
         empty_date = datetime.datetime.fromtimestamp(0)
 
         if cs_cache is None:
             # use no-cache version here
             try:
                 scm_repo = self.scm_instance(cache=False, config=config)
             except VCSError:
                 scm_repo = None
             empty = scm_repo is None or scm_repo.is_empty()
 
             if not empty:
                 cs_cache = scm_repo.get_commit(
                     pre_load=["author", "date", "message", "parents", "branch"])
             else:
                 cs_cache = EmptyCommit()
 
         if isinstance(cs_cache, BaseChangeset):
             cs_cache = cs_cache.__json__()
 
         def is_outdated(new_cs_cache):
             if (new_cs_cache['raw_id'] != self.changeset_cache['raw_id'] or
                 new_cs_cache['revision'] != self.changeset_cache['revision']):
                 return True
             return False
 
         # check if we have maybe already latest cached revision
         if is_outdated(cs_cache) or not self.changeset_cache:
             _current_datetime = datetime.datetime.utcnow()
             last_change = cs_cache.get('date') or _current_datetime
             # we check if last update is newer than the new value
             # if yes, we use the current timestamp instead. Imagine you get
             # old commit pushed 1y ago, we'd set last update 1y to ago.
             last_change_timestamp = datetime_to_time(last_change)
             current_timestamp = datetime_to_time(last_change)
             if last_change_timestamp > current_timestamp and not empty:
                 cs_cache['date'] = _current_datetime
 
             _date_latest = parse_datetime(cs_cache.get('date') or empty_date)
             cs_cache['updated_on'] = time.time()
             self.changeset_cache = cs_cache
             self.updated_on = last_change
             Session().add(self)
             Session().commit()
 
         else:
             if empty:
                 cs_cache = EmptyCommit().__json__()
             else:
                 cs_cache = self.changeset_cache
 
             _date_latest = parse_datetime(cs_cache.get('date') or empty_date)
 
             cs_cache['updated_on'] = time.time()
             self.changeset_cache = cs_cache
             self.updated_on = _date_latest
             Session().add(self)
             Session().commit()
 
         log.debug('updated repo `%s` with new commit cache %s, and last update_date: %s',
                   self.repo_name, cs_cache, _date_latest)
 
     @property
     def tip(self):
         return self.get_commit('tip')
 
     @property
     def author(self):
         return self.tip.author
 
     @property
     def last_change(self):
         return self.scm_instance().last_change
 
     def get_comments(self, revisions=None):
         """
         Returns comments for this repository grouped by revisions
 
         :param revisions: filter query by revisions only
         """
         cmts = ChangesetComment.query()\
             .filter(ChangesetComment.repo == self)
         if revisions:
             cmts = cmts.filter(ChangesetComment.revision.in_(revisions))
         grouped = collections.defaultdict(list)
         for cmt in cmts.all():
             grouped[cmt.revision].append(cmt)
         return grouped
 
     def statuses(self, revisions=None):
         """
         Returns statuses for this repository
 
         :param revisions: list of revisions to get statuses for
         """
         statuses = ChangesetStatus.query()\
             .filter(ChangesetStatus.repo == self)\
             .filter(ChangesetStatus.version == 0)
 
         if revisions:
             # Try doing the filtering in chunks to avoid hitting limits
             size = 500
             status_results = []
             for chunk in xrange(0, len(revisions), size):
                 status_results += statuses.filter(
                     ChangesetStatus.revision.in_(
                         revisions[chunk: chunk+size])
                 ).all()
         else:
             status_results = statuses.all()
 
         grouped = {}
 
         # maybe we have open new pullrequest without a status?
         stat = ChangesetStatus.STATUS_UNDER_REVIEW
         status_lbl = ChangesetStatus.get_status_lbl(stat)
         for pr in PullRequest.query().filter(PullRequest.source_repo == self).all():
             for rev in pr.revisions:
                 pr_id = pr.pull_request_id
                 pr_repo = pr.target_repo.repo_name
                 grouped[rev] = [stat, status_lbl, pr_id, pr_repo]
 
         for stat in status_results:
             pr_id = pr_repo = None
             if stat.pull_request:
                 pr_id = stat.pull_request.pull_request_id
                 pr_repo = stat.pull_request.target_repo.repo_name
             grouped[stat.revision] = [str(stat.status), stat.status_lbl,
                                       pr_id, pr_repo]
         return grouped
 
     # ==========================================================================
     # SCM CACHE INSTANCE
     # ==========================================================================
 
     def scm_instance(self, **kwargs):
         import rhodecode
 
         # Passing a config will not hit the cache currently only used
         # for repo2dbmapper
         config = kwargs.pop('config', None)
         cache = kwargs.pop('cache', None)
         vcs_full_cache = kwargs.pop('vcs_full_cache', None)
         if vcs_full_cache is not None:
             # allows override global config
             full_cache = vcs_full_cache
         else:
             full_cache = str2bool(rhodecode.CONFIG.get('vcs_full_cache'))
         # if cache is NOT defined use default global, else we have a full
         # control over cache behaviour
         if cache is None and full_cache and not config:
             log.debug('Initializing pure cached instance for %s', self.repo_path)
             return self._get_instance_cached()
 
         # cache here is sent to the "vcs server"
         return self._get_instance(cache=bool(cache), config=config)
 
     def _get_instance_cached(self):
         from rhodecode.lib import rc_cache
 
         cache_namespace_uid = 'cache_repo_instance.{}'.format(self.repo_id)
         invalidation_namespace = CacheKey.REPO_INVALIDATION_NAMESPACE.format(
             repo_id=self.repo_id)
         region = rc_cache.get_or_create_region('cache_repo_longterm', cache_namespace_uid)
 
         @region.conditional_cache_on_arguments(namespace=cache_namespace_uid)
         def get_instance_cached(repo_id, context_id, _cache_state_uid):
             return self._get_instance(repo_state_uid=_cache_state_uid)
 
         # we must use thread scoped cache here,
         # because each thread of gevent needs it's own not shared connection and cache
         # we also alter `args` so the cache key is individual for every green thread.
         inv_context_manager = rc_cache.InvalidationContext(
             uid=cache_namespace_uid, invalidation_namespace=invalidation_namespace,
             thread_scoped=True)
         with inv_context_manager as invalidation_context:
             cache_state_uid = invalidation_context.cache_data['cache_state_uid']
             args = (self.repo_id, inv_context_manager.cache_key, cache_state_uid)
 
             # re-compute and store cache if we get invalidate signal
             if invalidation_context.should_invalidate():
                 instance = get_instance_cached.refresh(*args)
             else:
                 instance = get_instance_cached(*args)
 
             log.debug('Repo instance fetched in %.4fs', inv_context_manager.compute_time)
             return instance
 
     def _get_instance(self, cache=True, config=None, repo_state_uid=None):
         log.debug('Initializing %s instance `%s` with cache flag set to: %s',
                   self.repo_type, self.repo_path, cache)
         config = config or self._config
         custom_wire = {
             'cache': cache,  # controls the vcs.remote cache
             'repo_state_uid': repo_state_uid
         }
         repo = get_vcs_instance(
             repo_path=safe_str(self.repo_full_path),
             config=config,
             with_wire=custom_wire,
             create=False,
             _vcs_alias=self.repo_type)
         if repo is not None:
             repo.count()  # cache rebuild
         return repo
 
     def get_shadow_repository_path(self, workspace_id):
         from rhodecode.lib.vcs.backends.base import BaseRepository
         shadow_repo_path = BaseRepository._get_shadow_repository_path(
             self.repo_full_path, self.repo_id, workspace_id)
         return shadow_repo_path
 
     def __json__(self):
         return {'landing_rev': self.landing_rev}
 
     def get_dict(self):
 
         # Since we transformed `repo_name` to a hybrid property, we need to
         # keep compatibility with the code which uses `repo_name` field.
 
         result = super(Repository, self).get_dict()
         result['repo_name'] = result.pop('_repo_name', None)
         return result
 
 
 class RepoGroup(Base, BaseModel):
     __tablename__ = 'groups'
     __table_args__ = (
         UniqueConstraint('group_name', 'group_parent_id'),
         base_table_args,
     )
     __mapper_args__ = {'order_by': 'group_name'}
 
     CHOICES_SEPARATOR = '/'  # used to generate select2 choices for nested groups
 
     group_id = Column("group_id", Integer(), nullable=False, unique=True, default=None, primary_key=True)
     _group_name = Column("group_name", String(255), nullable=False, unique=True, default=None)
     group_name_hash = Column("repo_group_name_hash", String(1024), nullable=False, unique=False)
     group_parent_id = Column("group_parent_id", Integer(), ForeignKey('groups.group_id'), nullable=True, unique=None, default=None)
     group_description = Column("group_description", String(10000), nullable=True, unique=None, default=None)
     enable_locking = Column("enable_locking", Boolean(), nullable=False, unique=None, default=False)
     user_id = Column("user_id", Integer(), ForeignKey('users.user_id'), nullable=False, unique=False, default=None)
     created_on = Column('created_on', DateTime(timezone=False), nullable=False, default=datetime.datetime.now)
     updated_on = Column('updated_on', DateTime(timezone=False), nullable=True, unique=None, default=datetime.datetime.now)
     personal = Column('personal', Boolean(), nullable=True, unique=None, default=None)
     _changeset_cache = Column("changeset_cache", LargeBinary(), nullable=True)  # JSON data
 
     repo_group_to_perm = relationship('UserRepoGroupToPerm', cascade='all', order_by='UserRepoGroupToPerm.group_to_perm_id')
     users_group_to_perm = relationship('UserGroupRepoGroupToPerm', cascade='all')
     parent_group = relationship('RepoGroup', remote_side=group_id)
     user = relationship('User')
     integrations = relationship('Integration', cascade="all, delete-orphan")
 
     # no cascade, set NULL
     scope_artifacts = relationship('FileStore', primaryjoin='FileStore.scope_repo_group_id==RepoGroup.group_id')
 
     def __init__(self, group_name='', parent_group=None):
         self.group_name = group_name
         self.parent_group = parent_group
 
     def __unicode__(self):
         return u"<%s('id:%s:%s')>" % (
             self.__class__.__name__, self.group_id, self.group_name)
 
     @hybrid_property
     def group_name(self):
         return self._group_name
 
     @group_name.setter
     def group_name(self, value):
         self._group_name = value
         self.group_name_hash = self.hash_repo_group_name(value)
 
     @classmethod
     def _load_changeset_cache(cls, repo_id, changeset_cache_raw):
         from rhodecode.lib.vcs.backends.base import EmptyCommit
         dummy = EmptyCommit().__json__()
         if not changeset_cache_raw:
             dummy['source_repo_id'] = repo_id
             return json.loads(json.dumps(dummy))
 
         try:
             return json.loads(changeset_cache_raw)
         except TypeError:
             return dummy
         except Exception:
             log.error(traceback.format_exc())
             return dummy
 
     @hybrid_property
     def changeset_cache(self):
         return self._load_changeset_cache('', self._changeset_cache)
 
     @changeset_cache.setter
     def changeset_cache(self, val):
         try:
             self._changeset_cache = json.dumps(val)
         except Exception:
             log.error(traceback.format_exc())
 
     @validates('group_parent_id')
     def validate_group_parent_id(self, key, val):
         """
         Check cycle references for a parent group to self
         """
         if self.group_id and val:
             assert val != self.group_id
 
         return val
 
     @hybrid_property
     def description_safe(self):
         from rhodecode.lib import helpers as h
         return h.escape(self.group_description)
 
     @classmethod
     def hash_repo_group_name(cls, repo_group_name):
         val = remove_formatting(repo_group_name)
         val = safe_str(val).lower()
         chars = []
         for c in val:
             if c not in string.ascii_letters:
                 c = str(ord(c))
             chars.append(c)
 
         return ''.join(chars)
 
     @classmethod
     def _generate_choice(cls, repo_group):
         from webhelpers2.html import literal as _literal
         _name = lambda k: _literal(cls.CHOICES_SEPARATOR.join(k))
         return repo_group.group_id, _name(repo_group.full_path_splitted)
 
     @classmethod
     def groups_choices(cls, groups=None, show_empty_group=True):
         if not groups:
             groups = cls.query().all()
 
         repo_groups = []
         if show_empty_group:
             repo_groups = [(-1, u'-- %s --' % _('No parent'))]
 
         repo_groups.extend([cls._generate_choice(x) for x in groups])
 
         repo_groups = sorted(
             repo_groups, key=lambda t: t[1].split(cls.CHOICES_SEPARATOR)[0])
         return repo_groups
 
     @classmethod
     def url_sep(cls):
         return URL_SEP
 
     @classmethod
     def get_by_group_name(cls, group_name, cache=False, case_insensitive=False):
         if case_insensitive:
             gr = cls.query().filter(func.lower(cls.group_name)
                                     == func.lower(group_name))
         else:
             gr = cls.query().filter(cls.group_name == group_name)
         if cache:
             name_key = _hash_key(group_name)
             gr = gr.options(
                 FromCache("sql_cache_short", "get_group_%s" % name_key))
         return gr.scalar()
 
     @classmethod
     def get_user_personal_repo_group(cls, user_id):
         user = User.get(user_id)
         if user.username == User.DEFAULT_USER:
             return None
 
         return cls.query()\
             .filter(cls.personal == true()) \
             .filter(cls.user == user) \
             .order_by(cls.group_id.asc()) \
             .first()
 
     @classmethod
     def get_all_repo_groups(cls, user_id=Optional(None), group_id=Optional(None),
                             case_insensitive=True):
         q = RepoGroup.query()
 
         if not isinstance(user_id, Optional):
             q = q.filter(RepoGroup.user_id == user_id)
 
         if not isinstance(group_id, Optional):
             q = q.filter(RepoGroup.group_parent_id == group_id)
 
         if case_insensitive:
             q = q.order_by(func.lower(RepoGroup.group_name))
         else:
             q = q.order_by(RepoGroup.group_name)
         return q.all()
 
     @property
     def parents(self, parents_recursion_limit=10):
         groups = []
         if self.parent_group is None:
             return groups
         cur_gr = self.parent_group
         groups.insert(0, cur_gr)
         cnt = 0
         while 1:
             cnt += 1
             gr = getattr(cur_gr, 'parent_group', None)
             cur_gr = cur_gr.parent_group
             if gr is None:
                 break
             if cnt == parents_recursion_limit:
                 # this will prevent accidental infinit loops
                 log.error('more than %s parents found for group %s, stopping '
                           'recursive parent fetching', parents_recursion_limit, self)
                 break
 
             groups.insert(0, gr)
         return groups
 
     @property
     def last_commit_cache_update_diff(self):
         return time.time() - (safe_int(self.changeset_cache.get('updated_on')) or 0)
 
     @classmethod
     def _load_commit_change(cls, last_commit_cache):
         from rhodecode.lib.vcs.utils.helpers import parse_datetime
         empty_date = datetime.datetime.fromtimestamp(0)
         date_latest = last_commit_cache.get('date', empty_date)
         try:
             return parse_datetime(date_latest)
         except Exception:
             return empty_date
 
     @property
     def last_commit_change(self):
         return self._load_commit_change(self.changeset_cache)
 
     @property
     def last_db_change(self):
         return self.updated_on
 
     @property
     def children(self):
         return RepoGroup.query().filter(RepoGroup.parent_group == self)
 
     @property
     def name(self):
         return self.group_name.split(RepoGroup.url_sep())[-1]
 
     @property
     def full_path(self):
         return self.group_name
 
     @property
     def full_path_splitted(self):
         return self.group_name.split(RepoGroup.url_sep())
 
     @property
     def repositories(self):
         return Repository.query()\
                 .filter(Repository.group == self)\
                 .order_by(Repository.repo_name)
 
     @property
     def repositories_recursive_count(self):
         cnt = self.repositories.count()
 
         def children_count(group):
             cnt = 0
             for child in group.children:
                 cnt += child.repositories.count()
                 cnt += children_count(child)
             return cnt
 
         return cnt + children_count(self)
 
     def _recursive_objects(self, include_repos=True, include_groups=True):
         all_ = []
 
         def _get_members(root_gr):
             if include_repos:
                 for r in root_gr.repositories:
                     all_.append(r)
             childs = root_gr.children.all()
             if childs:
                 for gr in childs:
                     if include_groups:
                         all_.append(gr)
                     _get_members(gr)
 
         root_group = []
         if include_groups:
             root_group = [self]
 
         _get_members(self)
         return root_group + all_
 
     def recursive_groups_and_repos(self):
         """
         Recursive return all groups, with repositories in those groups
         """
         return self._recursive_objects()
 
     def recursive_groups(self):
         """
         Returns all children groups for this group including children of children
         """
         return self._recursive_objects(include_repos=False)
 
     def recursive_repos(self):
         """
         Returns all children repositories for this group
         """
         return self._recursive_objects(include_groups=False)
 
     def get_new_name(self, group_name):
         """
         returns new full group name based on parent and new name
 
         :param group_name:
         """
         path_prefix = (self.parent_group.full_path_splitted if
                        self.parent_group else [])
         return RepoGroup.url_sep().join(path_prefix + [group_name])
 
     def update_commit_cache(self, config=None):
         """
         Update cache of last commit for newest repository inside this repository group.
         cache_keys should be::
 
             source_repo_id
             short_id
             raw_id
             revision
             parents
             message
             date
             author
 
         """
         from rhodecode.lib.vcs.utils.helpers import parse_datetime
         empty_date = datetime.datetime.fromtimestamp(0)
 
         def repo_groups_and_repos(root_gr):
             for _repo in root_gr.repositories:
                 yield _repo
             for child_group in root_gr.children.all():
                 yield child_group
 
         latest_repo_cs_cache = {}
         for obj in repo_groups_and_repos(self):
             repo_cs_cache = obj.changeset_cache
             date_latest = latest_repo_cs_cache.get('date', empty_date)
             date_current = repo_cs_cache.get('date', empty_date)
             current_timestamp = datetime_to_time(parse_datetime(date_latest))
             if current_timestamp < datetime_to_time(parse_datetime(date_current)):
                 latest_repo_cs_cache = repo_cs_cache
                 if hasattr(obj, 'repo_id'):
                     latest_repo_cs_cache['source_repo_id'] = obj.repo_id
                 else:
                     latest_repo_cs_cache['source_repo_id'] = repo_cs_cache.get('source_repo_id')
 
         _date_latest = parse_datetime(latest_repo_cs_cache.get('date') or empty_date)
 
         latest_repo_cs_cache['updated_on'] = time.time()
         self.changeset_cache = latest_repo_cs_cache
         self.updated_on = _date_latest
         Session().add(self)
         Session().commit()
 
         log.debug('updated repo group `%s` with new commit cache %s, and last update_date: %s',
                   self.group_name, latest_repo_cs_cache, _date_latest)
 
     def permissions(self, with_admins=True, with_owner=True,
                     expand_from_user_groups=False):
         """
         Permissions for repository groups
         """
         _admin_perm = 'group.admin'
 
         owner_row = []
         if with_owner:
             usr = AttributeDict(self.user.get_dict())
             usr.owner_row = True
             usr.permission = _admin_perm
             owner_row.append(usr)
 
         super_admin_ids = []
         super_admin_rows = []
         if with_admins:
             for usr in User.get_all_super_admins():
                 super_admin_ids.append(usr.user_id)
                 # if this admin is also owner, don't double the record
                 if usr.user_id == owner_row[0].user_id:
                     owner_row[0].admin_row = True
                 else:
                     usr = AttributeDict(usr.get_dict())
                     usr.admin_row = True
                     usr.permission = _admin_perm
                     super_admin_rows.append(usr)
 
         q = UserRepoGroupToPerm.query().filter(UserRepoGroupToPerm.group == self)
         q = q.options(joinedload(UserRepoGroupToPerm.group),
                       joinedload(UserRepoGroupToPerm.user),
                       joinedload(UserRepoGroupToPerm.permission),)
 
         # get owners and admins and permissions. We do a trick of re-writing
         # objects from sqlalchemy to named-tuples due to sqlalchemy session
         # has a global reference and changing one object propagates to all
         # others. This means if admin is also an owner admin_row that change
         # would propagate to both objects
         perm_rows = []
         for _usr in q.all():
             usr = AttributeDict(_usr.user.get_dict())
             # if this user is also owner/admin, mark as duplicate record
             if usr.user_id == owner_row[0].user_id or usr.user_id in super_admin_ids:
                 usr.duplicate_perm = True
             usr.permission = _usr.permission.permission_name
             perm_rows.append(usr)
 
         # filter the perm rows by 'default' first and then sort them by
         # admin,write,read,none permissions sorted again alphabetically in
         # each group
         perm_rows = sorted(perm_rows, key=display_user_sort)
 
         user_groups_rows = []
         if expand_from_user_groups:
             for ug in self.permission_user_groups(with_members=True):
                 for user_data in ug.members:
                     user_groups_rows.append(user_data)
 
         return super_admin_rows + owner_row + perm_rows + user_groups_rows
 
     def permission_user_groups(self, with_members=False):
         q = UserGroupRepoGroupToPerm.query()\
             .filter(UserGroupRepoGroupToPerm.group == self)
         q = q.options(joinedload(UserGroupRepoGroupToPerm.group),
                       joinedload(UserGroupRepoGroupToPerm.users_group),
                       joinedload(UserGroupRepoGroupToPerm.permission),)
 
         perm_rows = []
         for _user_group in q.all():
             entry = AttributeDict(_user_group.users_group.get_dict())
             entry.permission = _user_group.permission.permission_name
             if with_members:
                 entry.members = [x.user.get_dict()
                                  for x in _user_group.users_group.members]
             perm_rows.append(entry)
 
         perm_rows = sorted(perm_rows, key=display_user_group_sort)
         return perm_rows
 
     def get_api_data(self):
         """
         Common function for generating api data
 
         """
         group = self
         data = {
             'group_id': group.group_id,
             'group_name': group.group_name,
             'group_description': group.description_safe,
             'parent_group': group.parent_group.group_name if group.parent_group else None,
             'repositories': [x.repo_name for x in group.repositories],
             'owner': group.user.username,
         }
         return data
 
     def get_dict(self):
         # Since we transformed `group_name` to a hybrid property, we need to
         # keep compatibility with the code which uses `group_name` field.
         result = super(RepoGroup, self).get_dict()
         result['group_name'] = result.pop('_group_name', None)
         return result
 
 
 class Permission(Base, BaseModel):
     __tablename__ = 'permissions'
     __table_args__ = (
         Index('p_perm_name_idx', 'permission_name'),
         base_table_args,
     )
 
     PERMS = [
         ('hg.admin', _('RhodeCode Super Administrator')),
 
         ('repository.none', _('Repository no access')),
         ('repository.read', _('Repository read access')),
         ('repository.write', _('Repository write access')),
         ('repository.admin', _('Repository admin access')),
 
         ('group.none', _('Repository group no access')),
         ('group.read', _('Repository group read access')),
         ('group.write', _('Repository group write access')),
         ('group.admin', _('Repository group admin access')),
 
         ('usergroup.none', _('User group no access')),
         ('usergroup.read', _('User group read access')),
         ('usergroup.write', _('User group write access')),
         ('usergroup.admin', _('User group admin access')),
 
         ('branch.none', _('Branch no permissions')),
         ('branch.merge', _('Branch access by web merge')),
         ('branch.push', _('Branch access by push')),
         ('branch.push_force', _('Branch access by push with force')),
 
         ('hg.repogroup.create.false', _('Repository Group creation disabled')),
         ('hg.repogroup.create.true', _('Repository Group creation enabled')),
 
         ('hg.usergroup.create.false', _('User Group creation disabled')),
         ('hg.usergroup.create.true', _('User Group creation enabled')),
 
         ('hg.create.none', _('Repository creation disabled')),
         ('hg.create.repository', _('Repository creation enabled')),
         ('hg.create.write_on_repogroup.true', _('Repository creation enabled with write permission to a repository group')),
         ('hg.create.write_on_repogroup.false', _('Repository creation disabled with write permission to a repository group')),
 
         ('hg.fork.none', _('Repository forking disabled')),
         ('hg.fork.repository', _('Repository forking enabled')),
 
         ('hg.register.none', _('Registration disabled')),
         ('hg.register.manual_activate', _('User Registration with manual account activation')),
         ('hg.register.auto_activate', _('User Registration with automatic account activation')),
 
         ('hg.password_reset.enabled', _('Password reset enabled')),
         ('hg.password_reset.hidden', _('Password reset hidden')),
         ('hg.password_reset.disabled', _('Password reset disabled')),
 
         ('hg.extern_activate.manual', _('Manual activation of external account')),
         ('hg.extern_activate.auto', _('Automatic activation of external account')),
 
         ('hg.inherit_default_perms.false', _('Inherit object permissions from default user disabled')),
         ('hg.inherit_default_perms.true', _('Inherit object permissions from default user enabled')),
     ]
 
     # definition of system default permissions for DEFAULT user, created on
     # system setup
     DEFAULT_USER_PERMISSIONS = [
         # object perms
         'repository.read',
         'group.read',
         'usergroup.read',
         # branch, for backward compat we need same value as before so forced pushed
         'branch.push_force',
         # global
         'hg.create.repository',
         'hg.repogroup.create.false',
         'hg.usergroup.create.false',
         'hg.create.write_on_repogroup.true',
         'hg.fork.repository',
         'hg.register.manual_activate',
         'hg.password_reset.enabled',
         'hg.extern_activate.auto',
         'hg.inherit_default_perms.true',
     ]
 
     # defines which permissions are more important higher the more important
     # Weight defines which permissions are more important.
     # The higher number the more important.
     PERM_WEIGHTS = {
         'repository.none': 0,
         'repository.read': 1,
         'repository.write': 3,
         'repository.admin': 4,
 
         'group.none': 0,
         'group.read': 1,
         'group.write': 3,
         'group.admin': 4,
 
         'usergroup.none': 0,
         'usergroup.read': 1,
         'usergroup.write': 3,
         'usergroup.admin': 4,
 
         'branch.none': 0,
         'branch.merge': 1,
         'branch.push': 3,
         'branch.push_force': 4,
 
         'hg.repogroup.create.false': 0,
         'hg.repogroup.create.true': 1,
 
         'hg.usergroup.create.false': 0,
         'hg.usergroup.create.true': 1,
 
         'hg.fork.none': 0,
         'hg.fork.repository': 1,
         'hg.create.none': 0,
         'hg.create.repository': 1
     }
 
     permission_id = Column("permission_id", Integer(), nullable=False, unique=True, default=None, primary_key=True)
     permission_name = Column("permission_name", String(255), nullable=True, unique=None, default=None)
     permission_longname = Column("permission_longname", String(255), nullable=True, unique=None, default=None)
 
     def __unicode__(self):
         return u"<%s('%s:%s')>" % (
             self.__class__.__name__, self.permission_id, self.permission_name
         )
 
     @classmethod
     def get_by_key(cls, key):
         return cls.query().filter(cls.permission_name == key).scalar()
 
     @classmethod
     def get_default_repo_perms(cls, user_id, repo_id=None):
         q = Session().query(UserRepoToPerm, Repository, Permission)\
             .join((Permission, UserRepoToPerm.permission_id == Permission.permission_id))\
             .join((Repository, UserRepoToPerm.repository_id == Repository.repo_id))\
             .filter(UserRepoToPerm.user_id == user_id)
         if repo_id:
             q = q.filter(UserRepoToPerm.repository_id == repo_id)
         return q.all()
 
     @classmethod
     def get_default_repo_branch_perms(cls, user_id, repo_id=None):
         q = Session().query(UserToRepoBranchPermission, UserRepoToPerm, Permission) \
             .join(
                 Permission,
                 UserToRepoBranchPermission.permission_id == Permission.permission_id) \
             .join(
                 UserRepoToPerm,
                 UserToRepoBranchPermission.rule_to_perm_id == UserRepoToPerm.repo_to_perm_id) \
             .filter(UserRepoToPerm.user_id == user_id)
 
         if repo_id:
             q = q.filter(UserToRepoBranchPermission.repository_id == repo_id)
         return q.order_by(UserToRepoBranchPermission.rule_order).all()
 
     @classmethod
     def get_default_repo_perms_from_user_group(cls, user_id, repo_id=None):
         q = Session().query(UserGroupRepoToPerm, Repository, Permission)\
             .join(
                 Permission,
                 UserGroupRepoToPerm.permission_id == Permission.permission_id)\
             .join(
                 Repository,
                 UserGroupRepoToPerm.repository_id == Repository.repo_id)\
             .join(
                 UserGroup,
                 UserGroupRepoToPerm.users_group_id ==
                 UserGroup.users_group_id)\
             .join(
                 UserGroupMember,
                 UserGroupRepoToPerm.users_group_id ==
                 UserGroupMember.users_group_id)\
             .filter(
                 UserGroupMember.user_id == user_id,
                 UserGroup.users_group_active == true())
         if repo_id:
             q = q.filter(UserGroupRepoToPerm.repository_id == repo_id)
         return q.all()
 
     @classmethod
     def get_default_repo_branch_perms_from_user_group(cls, user_id, repo_id=None):
         q = Session().query(UserGroupToRepoBranchPermission, UserGroupRepoToPerm, Permission) \
             .join(
                 Permission,
                 UserGroupToRepoBranchPermission.permission_id == Permission.permission_id) \
             .join(
                 UserGroupRepoToPerm,
                 UserGroupToRepoBranchPermission.rule_to_perm_id == UserGroupRepoToPerm.users_group_to_perm_id) \
             .join(
                 UserGroup,
                 UserGroupRepoToPerm.users_group_id == UserGroup.users_group_id) \
             .join(
                 UserGroupMember,
                 UserGroupRepoToPerm.users_group_id == UserGroupMember.users_group_id) \
             .filter(
                 UserGroupMember.user_id == user_id,
                 UserGroup.users_group_active == true())
 
         if repo_id:
             q = q.filter(UserGroupToRepoBranchPermission.repository_id == repo_id)
         return q.order_by(UserGroupToRepoBranchPermission.rule_order).all()
 
     @classmethod
     def get_default_group_perms(cls, user_id, repo_group_id=None):
         q = Session().query(UserRepoGroupToPerm, RepoGroup, Permission)\
             .join(
                 Permission,
                 UserRepoGroupToPerm.permission_id == Permission.permission_id)\
             .join(
                 RepoGroup,
                 UserRepoGroupToPerm.group_id == RepoGroup.group_id)\
             .filter(UserRepoGroupToPerm.user_id == user_id)
         if repo_group_id:
             q = q.filter(UserRepoGroupToPerm.group_id == repo_group_id)
         return q.all()
 
     @classmethod
     def get_default_group_perms_from_user_group(
             cls, user_id, repo_group_id=None):
         q = Session().query(UserGroupRepoGroupToPerm, RepoGroup, Permission)\
             .join(
                 Permission,
                 UserGroupRepoGroupToPerm.permission_id ==
                 Permission.permission_id)\
             .join(
                 RepoGroup,
                 UserGroupRepoGroupToPerm.group_id == RepoGroup.group_id)\
             .join(
                 UserGroup,
                 UserGroupRepoGroupToPerm.users_group_id ==
                 UserGroup.users_group_id)\
             .join(
                 UserGroupMember,
                 UserGroupRepoGroupToPerm.users_group_id ==
                 UserGroupMember.users_group_id)\
             .filter(
                 UserGroupMember.user_id == user_id,
                 UserGroup.users_group_active == true())
         if repo_group_id:
             q = q.filter(UserGroupRepoGroupToPerm.group_id == repo_group_id)
         return q.all()
 
     @classmethod
     def get_default_user_group_perms(cls, user_id, user_group_id=None):
         q = Session().query(UserUserGroupToPerm, UserGroup, Permission)\
             .join((Permission, UserUserGroupToPerm.permission_id == Permission.permission_id))\
             .join((UserGroup, UserUserGroupToPerm.user_group_id == UserGroup.users_group_id))\
             .filter(UserUserGroupToPerm.user_id == user_id)
         if user_group_id:
             q = q.filter(UserUserGroupToPerm.user_group_id == user_group_id)
         return q.all()
 
     @classmethod
     def get_default_user_group_perms_from_user_group(
             cls, user_id, user_group_id=None):
         TargetUserGroup = aliased(UserGroup, name='target_user_group')
         q = Session().query(UserGroupUserGroupToPerm, UserGroup, Permission)\
             .join(
                 Permission,
                 UserGroupUserGroupToPerm.permission_id ==
                 Permission.permission_id)\
             .join(
                 TargetUserGroup,
                 UserGroupUserGroupToPerm.target_user_group_id ==
                 TargetUserGroup.users_group_id)\
             .join(
                 UserGroup,
                 UserGroupUserGroupToPerm.user_group_id ==
                 UserGroup.users_group_id)\
             .join(
                 UserGroupMember,
                 UserGroupUserGroupToPerm.user_group_id ==
                 UserGroupMember.users_group_id)\
             .filter(
                 UserGroupMember.user_id == user_id,
                 UserGroup.users_group_active == true())
         if user_group_id:
             q = q.filter(
                 UserGroupUserGroupToPerm.user_group_id == user_group_id)
 
         return q.all()
 
 
 class UserRepoToPerm(Base, BaseModel):
     __tablename__ = 'repo_to_perm'
     __table_args__ = (
         UniqueConstraint('user_id', 'repository_id', 'permission_id'),
         base_table_args
     )
 
     repo_to_perm_id = Column("repo_to_perm_id", Integer(), nullable=False, unique=True, default=None, primary_key=True)
     user_id = Column("user_id", Integer(), ForeignKey('users.user_id'), nullable=False, unique=None, default=None)
     permission_id = Column("permission_id", Integer(), ForeignKey('permissions.permission_id'), nullable=False, unique=None, default=None)
     repository_id = Column("repository_id", Integer(), ForeignKey('repositories.repo_id'), nullable=False, unique=None, default=None)
 
     user = relationship('User')
     repository = relationship('Repository')
     permission = relationship('Permission')
 
     branch_perm_entry = relationship('UserToRepoBranchPermission', cascade="all, delete-orphan", lazy='joined')
 
     @classmethod
     def create(cls, user, repository, permission):
         n = cls()
         n.user = user
         n.repository = repository
         n.permission = permission
         Session().add(n)
         return n
 
     def __unicode__(self):
         return u'<%s => %s >' % (self.user, self.repository)
 
 
 class UserUserGroupToPerm(Base, BaseModel):
     __tablename__ = 'user_user_group_to_perm'
     __table_args__ = (
         UniqueConstraint('user_id', 'user_group_id', 'permission_id'),
         base_table_args
     )
 
     user_user_group_to_perm_id = Column("user_user_group_to_perm_id", Integer(), nullable=False, unique=True, default=None, primary_key=True)
     user_id = Column("user_id", Integer(), ForeignKey('users.user_id'), nullable=False, unique=None, default=None)
     permission_id = Column("permission_id", Integer(), ForeignKey('permissions.permission_id'), nullable=False, unique=None, default=None)
     user_group_id = Column("user_group_id", Integer(), ForeignKey('users_groups.users_group_id'), nullable=False, unique=None, default=None)
 
     user = relationship('User')
     user_group = relationship('UserGroup')
     permission = relationship('Permission')
 
     @classmethod
     def create(cls, user, user_group, permission):
         n = cls()
         n.user = user
         n.user_group = user_group
         n.permission = permission
         Session().add(n)
         return n
 
     def __unicode__(self):
         return u'<%s => %s >' % (self.user, self.user_group)
 
 
 class UserToPerm(Base, BaseModel):
     __tablename__ = 'user_to_perm'
     __table_args__ = (
         UniqueConstraint('user_id', 'permission_id'),
         base_table_args
     )
 
     user_to_perm_id = Column("user_to_perm_id", Integer(), nullable=False, unique=True, default=None, primary_key=True)
     user_id = Column("user_id", Integer(), ForeignKey('users.user_id'), nullable=False, unique=None, default=None)
     permission_id = Column("permission_id", Integer(), ForeignKey('permissions.permission_id'), nullable=False, unique=None, default=None)
 
     user = relationship('User')
     permission = relationship('Permission', lazy='joined')
 
     def __unicode__(self):
         return u'<%s => %s >' % (self.user, self.permission)
 
 
 class UserGroupRepoToPerm(Base, BaseModel):
     __tablename__ = 'users_group_repo_to_perm'
     __table_args__ = (
         UniqueConstraint('repository_id', 'users_group_id', 'permission_id'),
         base_table_args
     )
 
     users_group_to_perm_id = Column("users_group_to_perm_id", Integer(), nullable=False, unique=True, default=None, primary_key=True)
     users_group_id = Column("users_group_id", Integer(), ForeignKey('users_groups.users_group_id'), nullable=False, unique=None, default=None)
     permission_id = Column("permission_id", Integer(), ForeignKey('permissions.permission_id'), nullable=False, unique=None, default=None)
     repository_id = Column("repository_id", Integer(), ForeignKey('repositories.repo_id'), nullable=False, unique=None, default=None)
 
     users_group = relationship('UserGroup')
     permission = relationship('Permission')
     repository = relationship('Repository')
     user_group_branch_perms = relationship('UserGroupToRepoBranchPermission', cascade='all')
 
     @classmethod
     def create(cls, users_group, repository, permission):
         n = cls()
         n.users_group = users_group
         n.repository = repository
         n.permission = permission
         Session().add(n)
         return n
 
     def __unicode__(self):
         return u'<UserGroupRepoToPerm:%s => %s >' % (self.users_group, self.repository)
 
 
 class UserGroupUserGroupToPerm(Base, BaseModel):
     __tablename__ = 'user_group_user_group_to_perm'
     __table_args__ = (
         UniqueConstraint('target_user_group_id', 'user_group_id', 'permission_id'),
         CheckConstraint('target_user_group_id != user_group_id'),
         base_table_args
     )
 
     user_group_user_group_to_perm_id = Column("user_group_user_group_to_perm_id", Integer(), nullable=False, unique=True, default=None, primary_key=True)
     target_user_group_id = Column("target_user_group_id", Integer(), ForeignKey('users_groups.users_group_id'), nullable=False, unique=None, default=None)
     permission_id = Column("permission_id", Integer(), ForeignKey('permissions.permission_id'), nullable=False, unique=None, default=None)
     user_group_id = Column("user_group_id", Integer(), ForeignKey('users_groups.users_group_id'), nullable=False, unique=None, default=None)
 
     target_user_group = relationship('UserGroup', primaryjoin='UserGroupUserGroupToPerm.target_user_group_id==UserGroup.users_group_id')
     user_group = relationship('UserGroup', primaryjoin='UserGroupUserGroupToPerm.user_group_id==UserGroup.users_group_id')
     permission = relationship('Permission')
 
     @classmethod
     def create(cls, target_user_group, user_group, permission):
         n = cls()
         n.target_user_group = target_user_group
         n.user_group = user_group
         n.permission = permission
         Session().add(n)
         return n
 
     def __unicode__(self):
         return u'<UserGroupUserGroup:%s => %s >' % (self.target_user_group, self.user_group)
 
 
 class UserGroupToPerm(Base, BaseModel):
     __tablename__ = 'users_group_to_perm'
     __table_args__ = (
         UniqueConstraint('users_group_id', 'permission_id',),
         base_table_args
     )
 
     users_group_to_perm_id = Column("users_group_to_perm_id", Integer(), nullable=False, unique=True, default=None, primary_key=True)
     users_group_id = Column("users_group_id", Integer(), ForeignKey('users_groups.users_group_id'), nullable=False, unique=None, default=None)
     permission_id = Column("permission_id", Integer(), ForeignKey('permissions.permission_id'), nullable=False, unique=None, default=None)
 
     users_group = relationship('UserGroup')
     permission = relationship('Permission')
 
 
 class UserRepoGroupToPerm(Base, BaseModel):
     __tablename__ = 'user_repo_group_to_perm'
     __table_args__ = (
         UniqueConstraint('user_id', 'group_id', 'permission_id'),
         base_table_args
     )
 
     group_to_perm_id = Column("group_to_perm_id", Integer(), nullable=False, unique=True, default=None, primary_key=True)
     user_id = Column("user_id", Integer(), ForeignKey('users.user_id'), nullable=False, unique=None, default=None)
     group_id = Column("group_id", Integer(), ForeignKey('groups.group_id'), nullable=False, unique=None, default=None)
     permission_id = Column("permission_id", Integer(), ForeignKey('permissions.permission_id'), nullable=False, unique=None, default=None)
 
     user = relationship('User')
     group = relationship('RepoGroup')
     permission = relationship('Permission')
 
     @classmethod
     def create(cls, user, repository_group, permission):
         n = cls()
         n.user = user
         n.group = repository_group
         n.permission = permission
         Session().add(n)
         return n
 
 
 class UserGroupRepoGroupToPerm(Base, BaseModel):
     __tablename__ = 'users_group_repo_group_to_perm'
     __table_args__ = (
         UniqueConstraint('users_group_id', 'group_id'),
         base_table_args
     )
 
     users_group_repo_group_to_perm_id = Column("users_group_repo_group_to_perm_id", Integer(), nullable=False, unique=True, default=None, primary_key=True)
     users_group_id = Column("users_group_id", Integer(), ForeignKey('users_groups.users_group_id'), nullable=False, unique=None, default=None)
     group_id = Column("group_id", Integer(), ForeignKey('groups.group_id'), nullable=False, unique=None, default=None)
     permission_id = Column("permission_id", Integer(), ForeignKey('permissions.permission_id'), nullable=False, unique=None, default=None)
 
     users_group = relationship('UserGroup')
     permission = relationship('Permission')
     group = relationship('RepoGroup')
 
     @classmethod
     def create(cls, user_group, repository_group, permission):
         n = cls()
         n.users_group = user_group
         n.group = repository_group
         n.permission = permission
         Session().add(n)
         return n
 
     def __unicode__(self):
         return u'<UserGroupRepoGroupToPerm:%s => %s >' % (self.users_group, self.group)
 
 
 class Statistics(Base, BaseModel):
     __tablename__ = 'statistics'
     __table_args__ = (
          base_table_args
     )
 
     stat_id = Column("stat_id", Integer(), nullable=False, unique=True, default=None, primary_key=True)
     repository_id = Column("repository_id", Integer(), ForeignKey('repositories.repo_id'), nullable=False, unique=True, default=None)
     stat_on_revision = Column("stat_on_revision", Integer(), nullable=False)
     commit_activity = Column("commit_activity", LargeBinary(1000000), nullable=False)#JSON data
     commit_activity_combined = Column("commit_activity_combined", LargeBinary(), nullable=False)#JSON data
     languages = Column("languages", LargeBinary(1000000), nullable=False)#JSON data
 
     repository = relationship('Repository', single_parent=True)
 
 
 class UserFollowing(Base, BaseModel):
     __tablename__ = 'user_followings'
     __table_args__ = (
         UniqueConstraint('user_id', 'follows_repository_id'),
         UniqueConstraint('user_id', 'follows_user_id'),
         base_table_args
     )
 
     user_following_id = Column("user_following_id", Integer(), nullable=False, unique=True, default=None, primary_key=True)
     user_id = Column("user_id", Integer(), ForeignKey('users.user_id'), nullable=False, unique=None, default=None)
     follows_repo_id = Column("follows_repository_id", Integer(), ForeignKey('repositories.repo_id'), nullable=True, unique=None, default=None)
     follows_user_id = Column("follows_user_id", Integer(), ForeignKey('users.user_id'), nullable=True, unique=None, default=None)
     follows_from = Column('follows_from', DateTime(timezone=False), nullable=True, unique=None, default=datetime.datetime.now)
 
     user = relationship('User', primaryjoin='User.user_id==UserFollowing.user_id')
 
     follows_user = relationship('User', primaryjoin='User.user_id==UserFollowing.follows_user_id')
     follows_repository = relationship('Repository', order_by='Repository.repo_name')
 
     @classmethod
     def get_repo_followers(cls, repo_id):
         return cls.query().filter(cls.follows_repo_id == repo_id)
 
 
 class CacheKey(Base, BaseModel):
     __tablename__ = 'cache_invalidation'
     __table_args__ = (
         UniqueConstraint('cache_key'),
         Index('key_idx', 'cache_key'),
         base_table_args,
     )
 
     CACHE_TYPE_FEED = 'FEED'
 
     # namespaces used to register process/thread aware caches
     REPO_INVALIDATION_NAMESPACE = 'repo_cache:{repo_id}'
     SETTINGS_INVALIDATION_NAMESPACE = 'system_settings'
 
     cache_id = Column("cache_id", Integer(), nullable=False, unique=True, default=None, primary_key=True)
     cache_key = Column("cache_key", String(255), nullable=True, unique=None, default=None)
     cache_args = Column("cache_args", String(255), nullable=True, unique=None, default=None)
     cache_state_uid = Column("cache_state_uid", String(255), nullable=True, unique=None, default=None)
     cache_active = Column("cache_active", Boolean(), nullable=True, unique=None, default=False)
 
     def __init__(self, cache_key, cache_args='', cache_state_uid=None):
         self.cache_key = cache_key
         self.cache_args = cache_args
         self.cache_active = False
         # first key should be same for all entries, since all workers should share it
         self.cache_state_uid = cache_state_uid or self.generate_new_state_uid()
 
     def __unicode__(self):
         return u"<%s('%s:%s[%s]')>" % (
             self.__class__.__name__,
             self.cache_id, self.cache_key, self.cache_active)
 
     def _cache_key_partition(self):
         prefix, repo_name, suffix = self.cache_key.partition(self.cache_args)
         return prefix, repo_name, suffix
 
     def get_prefix(self):
         """
         Try to extract prefix from existing cache key. The key could consist
         of prefix, repo_name, suffix
         """
         # this returns prefix, repo_name, suffix
         return self._cache_key_partition()[0]
 
     def get_suffix(self):
         """
         get suffix that might have been used in _get_cache_key to
         generate self.cache_key. Only used for informational purposes
         in repo_edit.mako.
         """
         # prefix, repo_name, suffix
         return self._cache_key_partition()[2]
 
     @classmethod
     def generate_new_state_uid(cls, based_on=None):
         if based_on:
             return str(uuid.uuid5(uuid.NAMESPACE_URL, safe_str(based_on)))
         else:
             return str(uuid.uuid4())
 
     @classmethod
     def delete_all_cache(cls):
         """
         Delete all cache keys from database.
         Should only be run when all instances are down and all entries
         thus stale.
         """
         cls.query().delete()
         Session().commit()
 
     @classmethod
     def set_invalidate(cls, cache_uid, delete=False):
         """
         Mark all caches of a repo as invalid in the database.
         """
 
         try:
             qry = Session().query(cls).filter(cls.cache_args == cache_uid)
             if delete:
                 qry.delete()
                 log.debug('cache objects deleted for cache args %s',
                           safe_str(cache_uid))
             else:
                 qry.update({"cache_active": False,
                             "cache_state_uid": cls.generate_new_state_uid()})
                 log.debug('cache objects marked as invalid for cache args %s',
                           safe_str(cache_uid))
 
             Session().commit()
         except Exception:
             log.exception(
                 'Cache key invalidation failed for cache args %s',
                 safe_str(cache_uid))
             Session().rollback()
 
     @classmethod
     def get_active_cache(cls, cache_key):
         inv_obj = cls.query().filter(cls.cache_key == cache_key).scalar()
         if inv_obj:
             return inv_obj
         return None
 
     @classmethod
     def get_namespace_map(cls, namespace):
         return {
             x.cache_key: x
             for x in cls.query().filter(cls.cache_args == namespace)}
 
 
 class ChangesetComment(Base, BaseModel):
     __tablename__ = 'changeset_comments'
     __table_args__ = (
         Index('cc_revision_idx', 'revision'),
         base_table_args,
     )
 
     COMMENT_OUTDATED = u'comment_outdated'
     COMMENT_TYPE_NOTE = u'note'
     COMMENT_TYPE_TODO = u'todo'
     COMMENT_TYPES = [COMMENT_TYPE_NOTE, COMMENT_TYPE_TODO]
 
     OP_IMMUTABLE = u'immutable'
     OP_CHANGEABLE = u'changeable'
 
     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=True)
     pull_request_id = Column("pull_request_id", Integer(), ForeignKey('pull_requests.pull_request_id'), nullable=True)
     pull_request_version_id = Column("pull_request_version_id", Integer(), ForeignKey('pull_request_versions.pull_request_version_id'), nullable=True)
     line_no = Column('line_no', Unicode(10), nullable=True)
     hl_lines = Column('hl_lines', Unicode(512), 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', UnicodeText().with_variant(UnicodeText(25000), 'mysql'), nullable=False)
     created_on = Column('created_on', DateTime(timezone=False), nullable=False, default=datetime.datetime.now)
     modified_at = Column('modified_at', DateTime(timezone=False), nullable=False, default=datetime.datetime.now)
     renderer = Column('renderer', Unicode(64), nullable=True)
     display_state = Column('display_state',  Unicode(128), nullable=True)
     immutable_state = Column('immutable_state', Unicode(128), nullable=True, default=OP_CHANGEABLE)
 
     comment_type = Column('comment_type',  Unicode(128), nullable=True, default=COMMENT_TYPE_NOTE)
     resolved_comment_id = Column('resolved_comment_id', Integer(), ForeignKey('changeset_comments.comment_id'), nullable=True)
 
     resolved_comment = relationship('ChangesetComment', remote_side=comment_id, back_populates='resolved_by')
     resolved_by = relationship('ChangesetComment', back_populates='resolved_comment')
 
     author = relationship('User', lazy='joined')
     repo = relationship('Repository')
     status_change = relationship('ChangesetStatus', cascade="all, delete-orphan", lazy='joined')
     pull_request = relationship('PullRequest', lazy='joined')
     pull_request_version = relationship('PullRequestVersion')
     history = relationship('ChangesetCommentHistory', cascade='all, delete-orphan', lazy='joined', order_by='ChangesetCommentHistory.version')
 
     @classmethod
     def get_users(cls, revision=None, pull_request_id=None):
         """
         Returns user associated with this ChangesetComment. ie those
         who actually commented
 
         :param cls:
         :param revision:
         """
         q = Session().query(User)\
                 .join(ChangesetComment.author)
         if revision:
             q = q.filter(cls.revision == revision)
         elif pull_request_id:
             q = q.filter(cls.pull_request_id == pull_request_id)
         return q.all()
 
     @classmethod
     def get_index_from_version(cls, pr_version, versions):
         num_versions = [x.pull_request_version_id for x in versions]
         try:
             return num_versions.index(pr_version) + 1
         except (IndexError, ValueError):
             return
 
     @property
     def outdated(self):
         return self.display_state == self.COMMENT_OUTDATED
 
     @property
     def outdated_js(self):
         return json.dumps(self.display_state == self.COMMENT_OUTDATED)
 
     @property
     def immutable(self):
         return self.immutable_state == self.OP_IMMUTABLE
 
     def outdated_at_version(self, version):
         """
         Checks if comment is outdated for given pull request version
         """
         def version_check():
             return self.pull_request_version_id and self.pull_request_version_id != version
 
         if self.is_inline:
             return self.outdated and version_check()
         else:
             # general comments don't have .outdated set, also latest don't have a version
             return version_check()
 
     def outdated_at_version_js(self, version):
         """
         Checks if comment is outdated for given pull request version
         """
         return json.dumps(self.outdated_at_version(version))
 
     def older_than_version(self, version):
         """
         Checks if comment is made from previous version than given
         """
         if version is None:
             return self.pull_request_version != version
 
         return self.pull_request_version < version
 
     def older_than_version_js(self, version):
         """
         Checks if comment is made from previous version than given
         """
         return json.dumps(self.older_than_version(version))
 
     @property
     def commit_id(self):
         """New style naming to stop using .revision"""
         return self.revision
 
     @property
     def resolved(self):
         return self.resolved_by[0] if self.resolved_by else None
 
     @property
     def is_todo(self):
         return self.comment_type == self.COMMENT_TYPE_TODO
 
     @property
     def is_inline(self):
         if self.line_no and self.f_path:
             return True
         return False
 
     @property
     def last_version(self):
         version = 0
         if self.history:
             version = self.history[-1].version
         return version
 
     def get_index_version(self, versions):
         return self.get_index_from_version(
             self.pull_request_version_id, versions)
 
     @property
     def review_status(self):
         if self.status_change:
             return self.status_change[0].status
 
     @property
     def review_status_lbl(self):
         if self.status_change:
             return self.status_change[0].status_lbl
 
     def __repr__(self):
         if self.comment_id:
             return '<DB:Comment #%s>' % self.comment_id
         else:
             return '<DB:Comment at %#x>' % id(self)
 
     def get_api_data(self):
         comment = self
 
         data = {
             'comment_id': comment.comment_id,
             'comment_type': comment.comment_type,
             'comment_text': comment.text,
             'comment_status': comment.status_change,
             'comment_f_path': comment.f_path,
             'comment_lineno': comment.line_no,
             'comment_author': comment.author,
             'comment_created_on': comment.created_on,
             'comment_resolved_by': self.resolved,
             'comment_commit_id': comment.revision,
             'comment_pull_request_id': comment.pull_request_id,
             'comment_last_version': self.last_version
         }
         return data
 
     def __json__(self):
         data = dict()
         data.update(self.get_api_data())
         return data
 
 
 class ChangesetCommentHistory(Base, BaseModel):
     __tablename__ = 'changeset_comments_history'
     __table_args__ = (
         Index('cch_comment_id_idx', 'comment_id'),
         base_table_args,
     )
 
     comment_history_id = Column('comment_history_id', Integer(), nullable=False, primary_key=True)
     comment_id = Column('comment_id', Integer(), ForeignKey('changeset_comments.comment_id'), nullable=False)
     version = Column("version", Integer(), nullable=False, default=0)
     created_by_user_id = Column('created_by_user_id', Integer(), ForeignKey('users.user_id'), nullable=False)
     text = Column('text', UnicodeText().with_variant(UnicodeText(25000), 'mysql'), nullable=False)
     created_on = Column('created_on', DateTime(timezone=False), nullable=False, default=datetime.datetime.now)
     deleted = Column('deleted', Boolean(), default=False)
 
     author = relationship('User', lazy='joined')
     comment = relationship('ChangesetComment', cascade="all, delete")
 
     @classmethod
     def get_version(cls, comment_id):
         q = Session().query(ChangesetCommentHistory).filter(
             ChangesetCommentHistory.comment_id == comment_id).order_by(ChangesetCommentHistory.version.desc())
         if q.count() == 0:
             return 1
         elif q.count() >= q[0].version:
             return q.count() + 1
         else:
             return q[0].version + 1
 
 
 class ChangesetStatus(Base, BaseModel):
     __tablename__ = 'changeset_statuses'
     __table_args__ = (
         Index('cs_revision_idx', 'revision'),
         Index('cs_version_idx', 'version'),
         UniqueConstraint('repo_id', 'revision', 'version'),
         base_table_args
     )
 
     STATUS_NOT_REVIEWED = DEFAULT = 'not_reviewed'
     STATUS_APPROVED = 'approved'
     STATUS_REJECTED = 'rejected'
     STATUS_UNDER_REVIEW = 'under_review'
 
     STATUSES = [
         (STATUS_NOT_REVIEWED, _("Not Reviewed")),  # (no icon) and default
         (STATUS_APPROVED, _("Approved")),
         (STATUS_REJECTED, _("Rejected")),
         (STATUS_UNDER_REVIEW, _("Under Review")),
     ]
 
     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')
 
     def __unicode__(self):
         return u"<%s('%s[v%s]:%s')>" % (
             self.__class__.__name__,
             self.status, self.version, self.author
         )
 
     @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)
 
     def get_api_data(self):
         status = self
         data = {
             'status_id': status.changeset_status_id,
             'status': status.status,
         }
         return data
 
     def __json__(self):
         data = dict()
         data.update(self.get_api_data())
         return data
 
 
 class _SetState(object):
     """
     Context processor allowing changing state for sensitive operation such as
     pull request update or merge
     """
 
     def __init__(self, pull_request, pr_state, back_state=None):
         self._pr = pull_request
         self._org_state = back_state or pull_request.pull_request_state
         self._pr_state = pr_state
         self._current_state = None
 
     def __enter__(self):
         log.debug('StateLock: entering set state context of pr %s, setting state to: `%s`',
                   self._pr, self._pr_state)
         self.set_pr_state(self._pr_state)
         return self
 
     def __exit__(self, exc_type, exc_val, exc_tb):
         if exc_val is not None:
             log.error(traceback.format_exc(exc_tb))
             return None
 
         self.set_pr_state(self._org_state)
         log.debug('StateLock: exiting set state context of pr %s, setting state to: `%s`',
                   self._pr, self._org_state)
 
     @property
     def state(self):
         return self._current_state
 
     def set_pr_state(self, pr_state):
         try:
             self._pr.pull_request_state = pr_state
             Session().add(self._pr)
             Session().commit()
             self._current_state = pr_state
         except Exception:
             log.exception('Failed to set PullRequest %s state to %s', self._pr, pr_state)
             raise
 
 
 class _PullRequestBase(BaseModel):
     """
     Common attributes of pull request and version entries.
     """
 
     # .status values
     STATUS_NEW = u'new'
     STATUS_OPEN = u'open'
     STATUS_CLOSED = u'closed'
 
     # available states
     STATE_CREATING = u'creating'
     STATE_UPDATING = u'updating'
     STATE_MERGING = u'merging'
     STATE_CREATED = u'created'
 
     title = Column('title', Unicode(255), nullable=True)
     description = Column(
         'description', UnicodeText().with_variant(UnicodeText(10240), 'mysql'),
         nullable=True)
     description_renderer = Column('description_renderer', Unicode(64), nullable=True)
 
     # new/open/closed status of pull request (not approve/reject/etc)
     status = Column('status', Unicode(255), nullable=False, default=STATUS_NEW)
     created_on = Column(
         'created_on', DateTime(timezone=False), nullable=False,
         default=datetime.datetime.now)
     updated_on = Column(
         'updated_on', DateTime(timezone=False), nullable=False,
         default=datetime.datetime.now)
 
     pull_request_state = Column("pull_request_state", String(255), nullable=True)
 
     @declared_attr
     def user_id(cls):
         return Column(
             "user_id", Integer(), ForeignKey('users.user_id'), nullable=False,
             unique=None)
 
     # 500 revisions max
     _revisions = Column(
         'revisions', UnicodeText().with_variant(UnicodeText(20500), 'mysql'))
 
     common_ancestor_id = Column('common_ancestor_id', Unicode(255), nullable=True)
 
     @declared_attr
     def source_repo_id(cls):
         # TODO: dan: rename column to source_repo_id
         return Column(
             'org_repo_id', Integer(), ForeignKey('repositories.repo_id'),
             nullable=False)
 
     _source_ref = Column('org_ref', Unicode(255), nullable=False)
 
     @hybrid_property
     def source_ref(self):
         return self._source_ref
 
     @source_ref.setter
     def source_ref(self, val):
         parts = (val or '').split(':')
         if len(parts) != 3:
             raise ValueError(
                 'Invalid reference format given: {}, expected X:Y:Z'.format(val))
         self._source_ref = safe_unicode(val)
 
     _target_ref = Column('other_ref', Unicode(255), nullable=False)
 
     @hybrid_property
     def target_ref(self):
         return self._target_ref
 
     @target_ref.setter
     def target_ref(self, val):
         parts = (val or '').split(':')
         if len(parts) != 3:
             raise ValueError(
                 'Invalid reference format given: {}, expected X:Y:Z'.format(val))
         self._target_ref = safe_unicode(val)
 
     @declared_attr
     def target_repo_id(cls):
         # TODO: dan: rename column to target_repo_id
         return Column(
             'other_repo_id', Integer(), ForeignKey('repositories.repo_id'),
             nullable=False)
 
     _shadow_merge_ref = Column('shadow_merge_ref', Unicode(255), nullable=True)
 
     # TODO: dan: rename column to last_merge_source_rev
     _last_merge_source_rev = Column(
         'last_merge_org_rev', String(40), nullable=True)
     # TODO: dan: rename column to last_merge_target_rev
     _last_merge_target_rev = Column(
         'last_merge_other_rev', String(40), nullable=True)
     _last_merge_status = Column('merge_status', Integer(), nullable=True)
     last_merge_metadata = Column(
         'last_merge_metadata', MutationObj.as_mutable(
             JsonType(dialect_map=dict(mysql=UnicodeText(16384)))))
 
     merge_rev = Column('merge_rev', String(40), nullable=True)
 
     reviewer_data = Column(
         'reviewer_data_json', MutationObj.as_mutable(
             JsonType(dialect_map=dict(mysql=UnicodeText(16384)))))
 
     @property
     def reviewer_data_json(self):
         return json.dumps(self.reviewer_data)
 
     @property
     def last_merge_metadata_parsed(self):
         metadata = {}
         if not self.last_merge_metadata:
             return metadata
 
         if hasattr(self.last_merge_metadata, 'de_coerce'):
             for k, v in self.last_merge_metadata.de_coerce().items():
                 if k in ['target_ref', 'source_ref']:
                     metadata[k] = Reference(v['type'], v['name'], v['commit_id'])
                 else:
                     if hasattr(v, 'de_coerce'):
                         metadata[k] = v.de_coerce()
                     else:
                         metadata[k] = v
         return metadata
 
     @property
     def work_in_progress(self):
         """checks if pull request is work in progress by checking the title"""
         title = self.title.upper()
         if re.match(r'^(\[WIP\]\s*|WIP:\s*|WIP\s+)', title):
             return True
         return False
 
     @hybrid_property
     def description_safe(self):
         from rhodecode.lib import helpers as h
         return h.escape(self.description)
 
     @hybrid_property
     def revisions(self):
         return self._revisions.split(':') if self._revisions else []
 
     @revisions.setter
     def revisions(self, val):
         self._revisions = u':'.join(val)
 
     @hybrid_property
     def last_merge_status(self):
         return safe_int(self._last_merge_status)
 
     @last_merge_status.setter
     def last_merge_status(self, val):
         self._last_merge_status = val
 
     @declared_attr
     def author(cls):
         return relationship('User', lazy='joined')
 
     @declared_attr
     def source_repo(cls):
         return relationship(
             'Repository',
             primaryjoin='%s.source_repo_id==Repository.repo_id' % cls.__name__)
 
     @property
     def source_ref_parts(self):
         return self.unicode_to_reference(self.source_ref)
 
     @declared_attr
     def target_repo(cls):
         return relationship(
             'Repository',
             primaryjoin='%s.target_repo_id==Repository.repo_id' % cls.__name__)
 
     @property
     def target_ref_parts(self):
         return self.unicode_to_reference(self.target_ref)
 
     @property
     def shadow_merge_ref(self):
         return self.unicode_to_reference(self._shadow_merge_ref)
 
     @shadow_merge_ref.setter
     def shadow_merge_ref(self, ref):
         self._shadow_merge_ref = self.reference_to_unicode(ref)
 
     @staticmethod
     def unicode_to_reference(raw):
         """
         Convert a unicode (or string) to a reference object.
         If unicode evaluates to False it returns None.
         """
         if raw:
             refs = raw.split(':')
             return Reference(*refs)
         else:
             return None
 
     @staticmethod
     def reference_to_unicode(ref):
         """
         Convert a reference object to unicode.
         If reference is None it returns None.
         """
         if ref:
             return u':'.join(ref)
         else:
             return None
 
     def get_api_data(self, with_merge_state=True):
         from rhodecode.model.pull_request import PullRequestModel
 
         pull_request = self
         if with_merge_state:
             merge_response, merge_status, msg = \
                 PullRequestModel().merge_status(pull_request)
             merge_state = {
                 'status': merge_status,
                 'message': safe_unicode(msg),
             }
         else:
             merge_state = {'status': 'not_available',
                            'message': 'not_available'}
 
         merge_data = {
             'clone_url': PullRequestModel().get_shadow_clone_url(pull_request),
             'reference': (
                 pull_request.shadow_merge_ref._asdict()
                 if pull_request.shadow_merge_ref else None),
         }
 
         data = {
             'pull_request_id': pull_request.pull_request_id,
             'url': PullRequestModel().get_url(pull_request),
             'title': pull_request.title,
             'description': pull_request.description,
             'status': pull_request.status,
             'state': pull_request.pull_request_state,
             'created_on': pull_request.created_on,
             'updated_on': pull_request.updated_on,
             'commit_ids': pull_request.revisions,
             'review_status': pull_request.calculated_review_status(),
             'mergeable': merge_state,
             'source': {
                 'clone_url': pull_request.source_repo.clone_url(),
                 'repository': pull_request.source_repo.repo_name,
                 'reference': {
                     'name': pull_request.source_ref_parts.name,
                     'type': pull_request.source_ref_parts.type,
                     'commit_id': pull_request.source_ref_parts.commit_id,
                 },
             },
             'target': {
                 'clone_url': pull_request.target_repo.clone_url(),
                 'repository': pull_request.target_repo.repo_name,
                 'reference': {
                     'name': pull_request.target_ref_parts.name,
                     'type': pull_request.target_ref_parts.type,
                     'commit_id': pull_request.target_ref_parts.commit_id,
                 },
             },
             'merge': merge_data,
             'author': pull_request.author.get_api_data(include_secrets=False,
                                                        details='basic'),
             'reviewers': [
                 {
                     'user': reviewer.get_api_data(include_secrets=False,
                                                   details='basic'),
                     'reasons': reasons,
                     'review_status': st[0][1].status if st else 'not_reviewed',
                 }
                 for obj, reviewer, reasons, mandatory, st in
                 pull_request.reviewers_statuses()
             ]
         }
 
         return data
 
     def set_state(self, pull_request_state, final_state=None):
         """
         # goes from initial state to updating to initial state.
         # initial state can be changed by specifying back_state=
         with pull_request_obj.set_state(PullRequest.STATE_UPDATING):
            pull_request.merge()
 
         :param pull_request_state:
         :param final_state:
 
         """
 
         return _SetState(self, pull_request_state, back_state=final_state)
 
 
 class PullRequest(Base, _PullRequestBase):
     __tablename__ = 'pull_requests'
     __table_args__ = (
         base_table_args,
     )
     LATEST_VER = 'latest'
 
     pull_request_id = Column(
         'pull_request_id', Integer(), nullable=False, primary_key=True)
 
     def __repr__(self):
         if self.pull_request_id:
             return '<DB:PullRequest #%s>' % self.pull_request_id
         else:
             return '<DB:PullRequest at %#x>' % id(self)
 
     reviewers = relationship('PullRequestReviewers', cascade="all, delete-orphan")
     statuses = relationship('ChangesetStatus', cascade="all, delete-orphan")
     comments = relationship('ChangesetComment', cascade="all, delete-orphan")
     versions = relationship('PullRequestVersion', cascade="all, delete-orphan",
                             lazy='dynamic')
 
     @classmethod
     def get_pr_display_object(cls, pull_request_obj, org_pull_request_obj,
                               internal_methods=None):
 
         class PullRequestDisplay(object):
             """
             Special object wrapper for showing PullRequest data via Versions
             It mimics PR object as close as possible. This is read only object
             just for display
             """
 
             def __init__(self, attrs, internal=None):
                 self.attrs = attrs
                 # internal have priority over the given ones via attrs
                 self.internal = internal or ['versions']
 
             def __getattr__(self, item):
                 if item in self.internal:
                     return getattr(self, item)
                 try:
                     return self.attrs[item]
                 except KeyError:
                     raise AttributeError(
                         '%s object has no attribute %s' % (self, item))
 
             def __repr__(self):
                 return '<DB:PullRequestDisplay #%s>' % self.attrs.get('pull_request_id')
 
             def versions(self):
                 return pull_request_obj.versions.order_by(
                     PullRequestVersion.pull_request_version_id).all()
 
             def is_closed(self):
                 return pull_request_obj.is_closed()
 
             def is_state_changing(self):
                 return pull_request_obj.is_state_changing()
 
             @property
             def pull_request_version_id(self):
                 return getattr(pull_request_obj, 'pull_request_version_id', None)
 
             @property
             def pull_request_last_version(self):
                 return pull_request_obj.pull_request_last_version
 
         attrs = StrictAttributeDict(pull_request_obj.get_api_data(with_merge_state=False))
 
         attrs.author = StrictAttributeDict(
             pull_request_obj.author.get_api_data())
         if pull_request_obj.target_repo:
             attrs.target_repo = StrictAttributeDict(
                 pull_request_obj.target_repo.get_api_data())
             attrs.target_repo.clone_url = pull_request_obj.target_repo.clone_url
 
         if pull_request_obj.source_repo:
             attrs.source_repo = StrictAttributeDict(
                 pull_request_obj.source_repo.get_api_data())
             attrs.source_repo.clone_url = pull_request_obj.source_repo.clone_url
 
         attrs.source_ref_parts = pull_request_obj.source_ref_parts
         attrs.target_ref_parts = pull_request_obj.target_ref_parts
         attrs.revisions = pull_request_obj.revisions
         attrs.common_ancestor_id = pull_request_obj.common_ancestor_id
         attrs.shadow_merge_ref = org_pull_request_obj.shadow_merge_ref
         attrs.reviewer_data = org_pull_request_obj.reviewer_data
         attrs.reviewer_data_json = org_pull_request_obj.reviewer_data_json
 
         return PullRequestDisplay(attrs, internal=internal_methods)
 
     def is_closed(self):
         return self.status == self.STATUS_CLOSED
 
     def is_state_changing(self):
         return self.pull_request_state != PullRequest.STATE_CREATED
 
     def __json__(self):
         return {
             'revisions': self.revisions,
             'versions': self.versions_count
         }
 
     def calculated_review_status(self):
         from rhodecode.model.changeset_status import ChangesetStatusModel
         return ChangesetStatusModel().calculated_review_status(self)
 
     def reviewers_statuses(self):
         from rhodecode.model.changeset_status import ChangesetStatusModel
         return ChangesetStatusModel().reviewers_statuses(self)
 
+    def get_pull_request_reviewers(self, role=None):
+        qry = PullRequestReviewers.query()\
+            .filter(PullRequestReviewers.pull_request_id == self.pull_request_id)
+        if role:
+            qry = qry.filter(PullRequestReviewers.role == role)
+
+        return qry.all()
+
+    @property
+    def reviewers_count(self):
+        qry = PullRequestReviewers.query()\
+            .filter(PullRequestReviewers.pull_request_id == self.pull_request_id)\
+            .filter(PullRequestReviewers.role == PullRequestReviewers.ROLE_REVIEWER)
+        return qry.count()
+
+    @property
+    def observers_count(self):
+        qry = PullRequestReviewers.query()\
+            .filter(PullRequestReviewers.pull_request_id == self.pull_request_id)\
+            .filter(PullRequestReviewers.role == PullRequestReviewers.ROLE_OBSERVER)
+        return qry.count()
+
+    def observers(self):
+        qry = PullRequestReviewers.query()\
+            .filter(PullRequestReviewers.pull_request_id == self.pull_request_id)\
+            .filter(PullRequestReviewers.role == PullRequestReviewers.ROLE_OBSERVER)\
+            .all()
+
+        for entry in qry:
+            yield entry, entry.user
+
     @property
     def workspace_id(self):
         from rhodecode.model.pull_request import PullRequestModel
         return PullRequestModel()._workspace_id(self)
 
     def get_shadow_repo(self):
         workspace_id = self.workspace_id
         shadow_repository_path = self.target_repo.get_shadow_repository_path(workspace_id)
         if os.path.isdir(shadow_repository_path):
             vcs_obj = self.target_repo.scm_instance()
             return vcs_obj.get_shadow_instance(shadow_repository_path)
 
     @property
     def versions_count(self):
         """
         return number of versions this PR have, e.g a PR that once been
         updated will have 2 versions
         """
         return self.versions.count() + 1
 
     @property
     def pull_request_last_version(self):
         return self.versions_count
 
 
 class PullRequestVersion(Base, _PullRequestBase):
     __tablename__ = 'pull_request_versions'
     __table_args__ = (
         base_table_args,
     )
 
     pull_request_version_id = Column(
         'pull_request_version_id', Integer(), nullable=False, primary_key=True)
     pull_request_id = Column(
         'pull_request_id', Integer(),
         ForeignKey('pull_requests.pull_request_id'), nullable=False)
     pull_request = relationship('PullRequest')
 
     def __repr__(self):
         if self.pull_request_version_id:
             return '<DB:PullRequestVersion #%s>' % self.pull_request_version_id
         else:
             return '<DB:PullRequestVersion at %#x>' % id(self)
 
     @property
     def reviewers(self):
         return self.pull_request.reviewers
 
     @property
     def versions(self):
         return self.pull_request.versions
 
     def is_closed(self):
         # calculate from original
         return self.pull_request.status == self.STATUS_CLOSED
 
     def is_state_changing(self):
         return self.pull_request.pull_request_state != PullRequest.STATE_CREATED
 
     def calculated_review_status(self):
         return self.pull_request.calculated_review_status()
 
     def reviewers_statuses(self):
         return self.pull_request.reviewers_statuses()
 
+    def observer(self):
+        return self.pull_request.observers()
+
 
 class PullRequestReviewers(Base, BaseModel):
     __tablename__ = 'pull_request_reviewers'
     __table_args__ = (
         base_table_args,
     )
     ROLE_REVIEWER = u'reviewer'
     ROLE_OBSERVER = u'observer'
+    ROLES = [ROLE_REVIEWER, ROLE_OBSERVER]
 
     @hybrid_property
     def reasons(self):
         if not self._reasons:
             return []
         return self._reasons
 
     @reasons.setter
     def reasons(self, val):
         val = val or []
         if any(not isinstance(x, compat.string_types) for x in val):
             raise Exception('invalid reasons type, must be list of strings')
         self._reasons = val
 
     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)
     _reasons = Column(
         'reason', MutationList.as_mutable(
             JsonType('list', dialect_map=dict(mysql=UnicodeText(16384)))))
 
     mandatory = Column("mandatory", Boolean(), nullable=False, default=False)
     role = Column('role', Unicode(255), nullable=True, default=ROLE_REVIEWER)
 
     user = relationship('User')
     pull_request = relationship('PullRequest')
 
     rule_data = Column(
         'rule_data_json',
         JsonType(dialect_map=dict(mysql=UnicodeText(16384))))
 
     def rule_user_group_data(self):
         """
         Returns the voting user group rule data for this reviewer
         """
 
         if self.rule_data and 'vote_rule' in self.rule_data:
             user_group_data = {}
             if 'rule_user_group_entry_id' in self.rule_data:
                 # means a group with voting rules !
                 user_group_data['id'] = self.rule_data['rule_user_group_entry_id']
                 user_group_data['name'] = self.rule_data['rule_name']
                 user_group_data['vote_rule'] = self.rule_data['vote_rule']
 
             return user_group_data
 
+    @classmethod
+    def get_pull_request_reviewers(cls, pull_request_id, role=None):
+        qry = PullRequestReviewers.query()\
+            .filter(PullRequestReviewers.pull_request_id == pull_request_id)
+        if role:
+            qry = qry.filter(PullRequestReviewers.role == role)
+
+        return qry.all()
+
     def __unicode__(self):
         return u"<%s('id:%s')>" % (self.__class__.__name__,
                                    self.pull_requests_reviewers_id)
 
 
 class Notification(Base, BaseModel):
     __tablename__ = 'notifications'
     __table_args__ = (
         Index('notification_type_idx', 'type'),
         base_table_args,
     )
 
     TYPE_CHANGESET_COMMENT = u'cs_comment'
     TYPE_MESSAGE = u'message'
     TYPE_MENTION = u'mention'
     TYPE_REGISTRATION = u'registration'
     TYPE_PULL_REQUEST = u'pull_request'
     TYPE_PULL_REQUEST_COMMENT = u'pull_request_comment'
     TYPE_PULL_REQUEST_UPDATE = u'pull_request_update'
 
     notification_id = Column('notification_id', Integer(), nullable=False, primary_key=True)
     subject = Column('subject', Unicode(512), nullable=True)
     body = Column('body', UnicodeText().with_variant(UnicodeText(50000), 'mysql'), 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(255))
 
     created_by_user = relationship('User')
     notifications_to_users = relationship('UserNotification', lazy='joined',
                                           cascade="all, delete-orphan")
 
     @property
     def recipients(self):
         return [x.user for x in UserNotification.query()\
                 .filter(UserNotification.notification == self)\
                 .order_by(UserNotification.user_id.asc()).all()]
 
     @classmethod
     def create(cls, created_by, subject, body, recipients, type_=None):
         if type_ is None:
             type_ = Notification.TYPE_MESSAGE
 
         notification = cls()
         notification.created_by_user = created_by
         notification.subject = subject
         notification.body = body
         notification.type_ = type_
         notification.created_on = datetime.datetime.now()
 
         # For each recipient link the created notification to his account
         for u in recipients:
             assoc = UserNotification()
             assoc.user_id = u.user_id
             assoc.notification = notification
 
             # if created_by is inside recipients mark his notification
             # as read
             if u.user_id == created_by.user_id:
                 assoc.read = True
             Session().add(assoc)
 
         Session().add(notification)
 
         return notification
 
 
 class UserNotification(Base, BaseModel):
     __tablename__ = 'user_to_notification'
     __table_args__ = (
         UniqueConstraint('user_id', 'notification_id'),
         base_table_args
     )
 
     user_id = Column('user_id', Integer(), ForeignKey('users.user_id'), primary_key=True)
     notification_id = Column("notification_id", Integer(), ForeignKey('notifications.notification_id'), primary_key=True)
     read = Column('read', Boolean, default=False)
     sent_on = Column('sent_on', DateTime(timezone=False), nullable=True, unique=None)
 
     user = relationship('User', lazy="joined")
     notification = relationship('Notification', lazy="joined",
                                 order_by=lambda: Notification.created_on.desc(),)
 
     def mark_as_read(self):
         self.read = True
         Session().add(self)
 
 
 class UserNotice(Base, BaseModel):
     __tablename__ = 'user_notices'
     __table_args__ = (
         base_table_args
     )
 
     NOTIFICATION_TYPE_MESSAGE = 'message'
     NOTIFICATION_TYPE_NOTICE = 'notice'
 
     NOTIFICATION_LEVEL_INFO = 'info'
     NOTIFICATION_LEVEL_WARNING = 'warning'
     NOTIFICATION_LEVEL_ERROR = 'error'
 
     user_notice_id = Column('gist_id', Integer(), primary_key=True)
 
     notice_subject = Column('notice_subject', Unicode(512), nullable=True)
     notice_body = Column('notice_body', UnicodeText().with_variant(UnicodeText(50000), 'mysql'), nullable=True)
 
     notice_read = Column('notice_read', Boolean, default=False)
 
     notification_level = Column('notification_level', String(1024), default=NOTIFICATION_LEVEL_INFO)
     notification_type = Column('notification_type', String(1024), default=NOTIFICATION_TYPE_NOTICE)
 
     notice_created_by = Column('notice_created_by', Integer(), ForeignKey('users.user_id'), nullable=True)
     notice_created_on = Column('notice_created_on', DateTime(timezone=False), nullable=False, default=datetime.datetime.now)
 
     user_id = Column('user_id', Integer(), ForeignKey('users.user_id'))
     user = relationship('User', lazy="joined", primaryjoin='User.user_id==UserNotice.user_id')
 
     @classmethod
     def create_for_user(cls, user, subject, body, notice_level=NOTIFICATION_LEVEL_INFO, allow_duplicate=False):
 
         if notice_level not in [cls.NOTIFICATION_LEVEL_ERROR,
                                 cls.NOTIFICATION_LEVEL_WARNING,
                                 cls.NOTIFICATION_LEVEL_INFO]:
             return
 
         from rhodecode.model.user import UserModel
         user = UserModel().get_user(user)
 
         new_notice = UserNotice()
         if not allow_duplicate:
             existing_msg = UserNotice().query() \
                 .filter(UserNotice.user == user) \
                 .filter(UserNotice.notice_body == body) \
                 .filter(UserNotice.notice_read == false()) \
                 .scalar()
             if existing_msg:
                 log.warning('Ignoring duplicate notice for user %s', user)
                 return
 
         new_notice.user = user
         new_notice.notice_subject = subject
         new_notice.notice_body = body
         new_notice.notification_level = notice_level
         Session().add(new_notice)
         Session().commit()
 
 
 class Gist(Base, BaseModel):
     __tablename__ = 'gists'
     __table_args__ = (
         Index('g_gist_access_id_idx', 'gist_access_id'),
         Index('g_created_on_idx', 'created_on'),
         base_table_args
     )
 
     GIST_PUBLIC = u'public'
     GIST_PRIVATE = u'private'
     DEFAULT_FILENAME = u'gistfile1.txt'
 
     ACL_LEVEL_PUBLIC = u'acl_public'
     ACL_LEVEL_PRIVATE = u'acl_private'
 
     gist_id = Column('gist_id', Integer(), primary_key=True)
     gist_access_id = Column('gist_access_id', Unicode(250))
     gist_description = Column('gist_description', UnicodeText().with_variant(UnicodeText(1024), 'mysql'))
     gist_owner = Column('user_id', Integer(), ForeignKey('users.user_id'), nullable=True)
     gist_expires = Column('gist_expires', Float(53), nullable=False)
     gist_type = Column('gist_type', Unicode(128), nullable=False)
     created_on = Column('created_on', DateTime(timezone=False), nullable=False, default=datetime.datetime.now)
     modified_at = Column('modified_at', DateTime(timezone=False), nullable=False, default=datetime.datetime.now)
     acl_level = Column('acl_level', Unicode(128), nullable=True)
 
     owner = relationship('User')
 
     def __repr__(self):
         return '<Gist:[%s]%s>' % (self.gist_type, self.gist_access_id)
 
     @hybrid_property
     def description_safe(self):
         from rhodecode.lib import helpers as h
         return h.escape(self.gist_description)
 
     @classmethod
     def get_or_404(cls, id_):
         from pyramid.httpexceptions import HTTPNotFound
 
         res = cls.query().filter(cls.gist_access_id == id_).scalar()
         if not res:
             raise HTTPNotFound()
         return res
 
     @classmethod
     def get_by_access_id(cls, gist_access_id):
         return cls.query().filter(cls.gist_access_id == gist_access_id).scalar()
 
     def gist_url(self):
         from rhodecode.model.gist import GistModel
         return GistModel().get_url(self)
 
     @classmethod
     def base_path(cls):
         """
         Returns base path when all gists are stored
 
         :param cls:
         """
         from rhodecode.model.gist import GIST_STORE_LOC
         q = Session().query(RhodeCodeUi)\
             .filter(RhodeCodeUi.ui_key == URL_SEP)
         q = q.options(FromCache("sql_cache_short", "repository_repo_path"))
         return os.path.join(q.one().ui_value, GIST_STORE_LOC)
 
     def get_api_data(self):
         """
         Common function for generating gist related data for API
         """
         gist = self
         data = {
             'gist_id': gist.gist_id,
             'type': gist.gist_type,
             'access_id': gist.gist_access_id,
             'description': gist.gist_description,
             'url': gist.gist_url(),
             'expires': gist.gist_expires,
             'created_on': gist.created_on,
             'modified_at': gist.modified_at,
             'content': None,
             'acl_level': gist.acl_level,
         }
         return data
 
     def __json__(self):
         data = dict(
         )
         data.update(self.get_api_data())
         return data
     # SCM functions
 
     def scm_instance(self, **kwargs):
         """
         Get an instance of VCS Repository
 
         :param kwargs:
         """
         from rhodecode.model.gist import GistModel
         full_repo_path = os.path.join(self.base_path(), self.gist_access_id)
         return get_vcs_instance(
             repo_path=safe_str(full_repo_path), create=False,
             _vcs_alias=GistModel.vcs_backend)
 
 
 class ExternalIdentity(Base, BaseModel):
     __tablename__ = 'external_identities'
     __table_args__ = (
         Index('local_user_id_idx', 'local_user_id'),
         Index('external_id_idx', 'external_id'),
         base_table_args
     )
 
     external_id = Column('external_id', Unicode(255), default=u'', primary_key=True)
     external_username = Column('external_username', Unicode(1024), default=u'')
     local_user_id = Column('local_user_id', Integer(), ForeignKey('users.user_id'), primary_key=True)
     provider_name = Column('provider_name', Unicode(255), default=u'', primary_key=True)
     access_token = Column('access_token', String(1024), default=u'')
     alt_token = Column('alt_token', String(1024), default=u'')
     token_secret = Column('token_secret', String(1024), default=u'')
 
     @classmethod
     def by_external_id_and_provider(cls, external_id, provider_name, local_user_id=None):
         """
         Returns ExternalIdentity instance based on search params
 
         :param external_id:
         :param provider_name:
         :return: ExternalIdentity
         """
         query = cls.query()
         query = query.filter(cls.external_id == external_id)
         query = query.filter(cls.provider_name == provider_name)
         if local_user_id:
             query = query.filter(cls.local_user_id == local_user_id)
         return query.first()
 
     @classmethod
     def user_by_external_id_and_provider(cls, external_id, provider_name):
         """
         Returns User instance based on search params
 
         :param external_id:
         :param provider_name:
         :return: User
         """
         query = User.query()
         query = query.filter(cls.external_id == external_id)
         query = query.filter(cls.provider_name == provider_name)
         query = query.filter(User.user_id == cls.local_user_id)
         return query.first()
 
     @classmethod
     def by_local_user_id(cls, local_user_id):
         """
         Returns all tokens for user
 
         :param local_user_id:
         :return: ExternalIdentity
         """
         query = cls.query()
         query = query.filter(cls.local_user_id == local_user_id)
         return query
 
     @classmethod
     def load_provider_plugin(cls, plugin_id):
         from rhodecode.authentication.base import loadplugin
         _plugin_id = 'egg:rhodecode-enterprise-ee#{}'.format(plugin_id)
         auth_plugin = loadplugin(_plugin_id)
         return auth_plugin
 
 
 class Integration(Base, BaseModel):
     __tablename__ = 'integrations'
     __table_args__ = (
         base_table_args
     )
 
     integration_id = Column('integration_id', Integer(), primary_key=True)
     integration_type = Column('integration_type', String(255))
     enabled = Column('enabled', Boolean(), nullable=False)
     name = Column('name', String(255), nullable=False)
     child_repos_only = Column('child_repos_only', Boolean(), nullable=False,
         default=False)
 
     settings = Column(
         'settings_json', MutationObj.as_mutable(
             JsonType(dialect_map=dict(mysql=UnicodeText(16384)))))
     repo_id = Column(
         'repo_id', Integer(), ForeignKey('repositories.repo_id'),
         nullable=True, unique=None, default=None)
     repo = relationship('Repository', lazy='joined')
 
     repo_group_id = Column(
         'repo_group_id', Integer(), ForeignKey('groups.group_id'),
         nullable=True, unique=None, default=None)
     repo_group = relationship('RepoGroup', lazy='joined')
 
     @property
     def scope(self):
         if self.repo:
             return repr(self.repo)
         if self.repo_group:
             if self.child_repos_only:
                 return repr(self.repo_group) + ' (child repos only)'
             else:
                 return repr(self.repo_group) + ' (recursive)'
         if self.child_repos_only:
             return 'root_repos'
         return 'global'
 
     def __repr__(self):
         return '<Integration(%r, %r)>' % (self.integration_type, self.scope)
 
 
 class RepoReviewRuleUser(Base, BaseModel):
     __tablename__ = 'repo_review_rules_users'
     __table_args__ = (
         base_table_args
     )
+    ROLE_REVIEWER = u'reviewer'
+    ROLE_OBSERVER = u'observer'
+    ROLES = [ROLE_REVIEWER, ROLE_OBSERVER]
 
     repo_review_rule_user_id = Column('repo_review_rule_user_id', Integer(), primary_key=True)
     repo_review_rule_id = Column("repo_review_rule_id", Integer(), ForeignKey('repo_review_rules.repo_review_rule_id'))
     user_id = Column("user_id", Integer(), ForeignKey('users.user_id'), nullable=False)
     mandatory = Column("mandatory", Boolean(), nullable=False, default=False)
+    role = Column('role', Unicode(255), nullable=True, default=ROLE_REVIEWER)
     user = relationship('User')
 
     def rule_data(self):
         return {
-            'mandatory': self.mandatory
+            'mandatory': self.mandatory,
+            'role': self.role,
         }
 
 
 class RepoReviewRuleUserGroup(Base, BaseModel):
     __tablename__ = 'repo_review_rules_users_groups'
     __table_args__ = (
         base_table_args
     )
 
     VOTE_RULE_ALL = -1
+    ROLE_REVIEWER = u'reviewer'
+    ROLE_OBSERVER = u'observer'
+    ROLES = [ROLE_REVIEWER, ROLE_OBSERVER]
 
     repo_review_rule_users_group_id = Column('repo_review_rule_users_group_id', Integer(), primary_key=True)
     repo_review_rule_id = Column("repo_review_rule_id", Integer(), ForeignKey('repo_review_rules.repo_review_rule_id'))
-    users_group_id = Column("users_group_id", Integer(),ForeignKey('users_groups.users_group_id'), nullable=False)
+    users_group_id = Column("users_group_id", Integer(), ForeignKey('users_groups.users_group_id'), nullable=False)
     mandatory = Column("mandatory", Boolean(), nullable=False, default=False)
+    role = Column('role', Unicode(255), nullable=True, default=ROLE_REVIEWER)
     vote_rule = Column("vote_rule", Integer(), nullable=True, default=VOTE_RULE_ALL)
     users_group = relationship('UserGroup')
 
     def rule_data(self):
         return {
             'mandatory': self.mandatory,
+            'role': self.role,
             'vote_rule': self.vote_rule
         }
 
     @property
     def vote_rule_label(self):
         if not self.vote_rule or self.vote_rule == self.VOTE_RULE_ALL:
             return 'all must vote'
         else:
             return 'min. vote {}'.format(self.vote_rule)
 
 
 class RepoReviewRule(Base, BaseModel):
     __tablename__ = 'repo_review_rules'
     __table_args__ = (
         base_table_args
     )
 
     repo_review_rule_id = Column(
         'repo_review_rule_id', Integer(), primary_key=True)
     repo_id = Column(
         "repo_id", Integer(), ForeignKey('repositories.repo_id'))
     repo = relationship('Repository', backref='review_rules')
 
     review_rule_name = Column('review_rule_name', String(255))
     _branch_pattern = Column("branch_pattern", UnicodeText().with_variant(UnicodeText(255), 'mysql'), default=u'*')  # glob
     _target_branch_pattern = Column("target_branch_pattern", UnicodeText().with_variant(UnicodeText(255), 'mysql'), default=u'*')  # glob
     _file_pattern = Column("file_pattern", UnicodeText().with_variant(UnicodeText(255), 'mysql'), default=u'*')  # glob
 
     use_authors_for_review = Column("use_authors_for_review", Boolean(), nullable=False, default=False)
     forbid_author_to_review = Column("forbid_author_to_review", Boolean(), nullable=False, default=False)
     forbid_commit_author_to_review = Column("forbid_commit_author_to_review", Boolean(), nullable=False, default=False)
     forbid_adding_reviewers = Column("forbid_adding_reviewers", Boolean(), nullable=False, default=False)
 
     rule_users = relationship('RepoReviewRuleUser')
     rule_user_groups = relationship('RepoReviewRuleUserGroup')
 
     def _validate_pattern(self, value):
         re.compile('^' + glob2re(value) + '$')
 
     @hybrid_property
     def source_branch_pattern(self):
         return self._branch_pattern or '*'
 
     @source_branch_pattern.setter
     def source_branch_pattern(self, value):
         self._validate_pattern(value)
         self._branch_pattern = value or '*'
 
     @hybrid_property
     def target_branch_pattern(self):
         return self._target_branch_pattern or '*'
 
     @target_branch_pattern.setter
     def target_branch_pattern(self, value):
         self._validate_pattern(value)
         self._target_branch_pattern = value or '*'
 
     @hybrid_property
     def file_pattern(self):
         return self._file_pattern or '*'
 
     @file_pattern.setter
     def file_pattern(self, value):
         self._validate_pattern(value)
         self._file_pattern = value or '*'
 
     def matches(self, source_branch, target_branch, files_changed):
         """
         Check if this review rule matches a branch/files in a pull request
 
         :param source_branch: source branch name for the commit
         :param target_branch: target branch name for the commit
         :param files_changed: list of file paths changed in the pull request
         """
 
         source_branch = source_branch or ''
         target_branch = target_branch or ''
         files_changed = files_changed or []
 
         branch_matches = True
         if source_branch or target_branch:
             if self.source_branch_pattern == '*':
                 source_branch_match = True
             else:
                 if self.source_branch_pattern.startswith('re:'):
                     source_pattern = self.source_branch_pattern[3:]
                 else:
                     source_pattern = '^' + glob2re(self.source_branch_pattern) + '$'
                 source_branch_regex = re.compile(source_pattern)
                 source_branch_match = bool(source_branch_regex.search(source_branch))
             if self.target_branch_pattern == '*':
                 target_branch_match = True
             else:
                 if self.target_branch_pattern.startswith('re:'):
                     target_pattern = self.target_branch_pattern[3:]
                 else:
                     target_pattern = '^' + glob2re(self.target_branch_pattern) + '$'
                 target_branch_regex = re.compile(target_pattern)
                 target_branch_match = bool(target_branch_regex.search(target_branch))
 
             branch_matches = source_branch_match and target_branch_match
 
         files_matches = True
         if self.file_pattern != '*':
             files_matches = False
             if self.file_pattern.startswith('re:'):
                 file_pattern = self.file_pattern[3:]
             else:
                 file_pattern = glob2re(self.file_pattern)
             file_regex = re.compile(file_pattern)
             for file_data in files_changed:
                 filename = file_data.get('filename')
 
                 if file_regex.search(filename):
                     files_matches = True
                     break
 
         return branch_matches and files_matches
 
     @property
     def review_users(self):
         """ Returns the users which this rule applies to """
 
         users = collections.OrderedDict()
 
         for rule_user in self.rule_users:
             if rule_user.user.active:
                 if rule_user.user not in users:
                     users[rule_user.user.username] = {
                         'user': rule_user.user,
                         'source': 'user',
                         'source_data': {},
                         'data': rule_user.rule_data()
                     }
 
         for rule_user_group in self.rule_user_groups:
             source_data = {
                 'user_group_id': rule_user_group.users_group.users_group_id,
                 'name': rule_user_group.users_group.users_group_name,
                 'members': len(rule_user_group.users_group.members)
             }
             for member in rule_user_group.users_group.members:
                 if member.user.active:
                     key = member.user.username
                     if key in users:
                         # skip this member as we have him already
                         # this prevents from override the "first" matched
                         # users with duplicates in multiple groups
                         continue
 
                     users[key] = {
                         'user': member.user,
                         'source': 'user_group',
                         'source_data': source_data,
                         'data': rule_user_group.rule_data()
                     }
 
         return users
 
     def user_group_vote_rule(self, user_id):
 
         rules = []
         if not self.rule_user_groups:
             return rules
 
         for user_group in self.rule_user_groups:
             user_group_members = [x.user_id for x in user_group.users_group.members]
             if user_id in user_group_members:
                 rules.append(user_group)
         return rules
 
     def __repr__(self):
         return '<RepoReviewerRule(id=%r, repo=%r)>' % (
             self.repo_review_rule_id, self.repo)
 
 
 class ScheduleEntry(Base, BaseModel):
     __tablename__ = 'schedule_entries'
     __table_args__ = (
         UniqueConstraint('schedule_name', name='s_schedule_name_idx'),
         UniqueConstraint('task_uid', name='s_task_uid_idx'),
         base_table_args,
     )
 
     schedule_types = ['crontab', 'timedelta', 'integer']
     schedule_entry_id = Column('schedule_entry_id', Integer(), primary_key=True)
 
     schedule_name = Column("schedule_name", String(255), nullable=False, unique=None, default=None)
     schedule_description = Column("schedule_description", String(10000), nullable=True, unique=None, default=None)
     schedule_enabled = Column("schedule_enabled", Boolean(), nullable=False, unique=None, default=True)
 
     _schedule_type = Column("schedule_type", String(255), nullable=False, unique=None, default=None)
     schedule_definition = Column('schedule_definition_json', MutationObj.as_mutable(JsonType(default=lambda: "", dialect_map=dict(mysql=LONGTEXT()))))
 
     schedule_last_run = Column('schedule_last_run', DateTime(timezone=False), nullable=True, unique=None, default=None)
     schedule_total_run_count = Column('schedule_total_run_count', Integer(), nullable=True, unique=None, default=0)
 
     # task
     task_uid = Column("task_uid", String(255), nullable=False, unique=None, default=None)
     task_dot_notation = Column("task_dot_notation", String(4096), nullable=False, unique=None, default=None)
     task_args = Column('task_args_json', MutationObj.as_mutable(JsonType(default=list, dialect_map=dict(mysql=LONGTEXT()))))
     task_kwargs = Column('task_kwargs_json', MutationObj.as_mutable(JsonType(default=dict, dialect_map=dict(mysql=LONGTEXT()))))
 
     created_on = Column('created_on', DateTime(timezone=False), nullable=False, default=datetime.datetime.now)
     updated_on = Column('updated_on', DateTime(timezone=False), nullable=True, unique=None, default=None)
 
     @hybrid_property
     def schedule_type(self):
         return self._schedule_type
 
     @schedule_type.setter
     def schedule_type(self, val):
         if val not in self.schedule_types:
             raise ValueError('Value must be on of `{}` and got `{}`'.format(
                 val, self.schedule_type))
 
         self._schedule_type = val
 
     @classmethod
     def get_uid(cls, obj):
         args = obj.task_args
         kwargs = obj.task_kwargs
         if isinstance(args, JsonRaw):
             try:
                 args = json.loads(args)
             except ValueError:
                 args = tuple()
 
         if isinstance(kwargs, JsonRaw):
             try:
                 kwargs = json.loads(kwargs)
             except ValueError:
                 kwargs = dict()
 
         dot_notation = obj.task_dot_notation
         val = '.'.join(map(safe_str, [
             sorted(dot_notation), args, sorted(kwargs.items())]))
         return hashlib.sha1(val).hexdigest()
 
     @classmethod
     def get_by_schedule_name(cls, schedule_name):
         return cls.query().filter(cls.schedule_name == schedule_name).scalar()
 
     @classmethod
     def get_by_schedule_id(cls, schedule_id):
         return cls.query().filter(cls.schedule_entry_id == schedule_id).scalar()
 
     @property
     def task(self):
         return self.task_dot_notation
 
     @property
     def schedule(self):
         from rhodecode.lib.celerylib.utils import raw_2_schedule
         schedule = raw_2_schedule(self.schedule_definition, self.schedule_type)
         return schedule
 
     @property
     def args(self):
         try:
             return list(self.task_args or [])
         except ValueError:
             return list()
 
     @property
     def kwargs(self):
         try:
             return dict(self.task_kwargs or {})
         except ValueError:
             return dict()
 
     def _as_raw(self, val):
         if hasattr(val, 'de_coerce'):
             val = val.de_coerce()
             if val:
                 val = json.dumps(val)
 
         return val
 
     @property
     def schedule_definition_raw(self):
         return self._as_raw(self.schedule_definition)
 
     @property
     def args_raw(self):
         return self._as_raw(self.task_args)
 
     @property
     def kwargs_raw(self):
         return self._as_raw(self.task_kwargs)
 
     def __repr__(self):
         return '<DB:ScheduleEntry({}:{})>'.format(
             self.schedule_entry_id, self.schedule_name)
 
 
 @event.listens_for(ScheduleEntry, 'before_update')
 def update_task_uid(mapper, connection, target):
     target.task_uid = ScheduleEntry.get_uid(target)
 
 
 @event.listens_for(ScheduleEntry, 'before_insert')
 def set_task_uid(mapper, connection, target):
     target.task_uid = ScheduleEntry.get_uid(target)
 
 
 class _BaseBranchPerms(BaseModel):
     @classmethod
     def compute_hash(cls, value):
         return sha1_safe(value)
 
     @hybrid_property
     def branch_pattern(self):
         return self._branch_pattern or '*'
 
     @hybrid_property
     def branch_hash(self):
         return self._branch_hash
 
     def _validate_glob(self, value):
         re.compile('^' + glob2re(value) + '$')
 
     @branch_pattern.setter
     def branch_pattern(self, value):
         self._validate_glob(value)
         self._branch_pattern = value or '*'
         # set the Hash when setting the branch pattern
         self._branch_hash = self.compute_hash(self._branch_pattern)
 
     def matches(self, branch):
         """
         Check if this the branch matches entry
 
         :param branch: branch name for the commit
         """
 
         branch = branch or ''
 
         branch_matches = True
         if branch:
             branch_regex = re.compile('^' + glob2re(self.branch_pattern) + '$')
             branch_matches = bool(branch_regex.search(branch))
 
         return branch_matches
 
 
 class UserToRepoBranchPermission(Base, _BaseBranchPerms):
     __tablename__ = 'user_to_repo_branch_permissions'
     __table_args__ = (
         base_table_args
     )
 
     branch_rule_id = Column('branch_rule_id', Integer(), primary_key=True)
 
     repository_id = Column('repository_id', Integer(), ForeignKey('repositories.repo_id'), nullable=False, unique=None, default=None)
     repo = relationship('Repository', backref='user_branch_perms')
 
     permission_id = Column('permission_id', Integer(), ForeignKey('permissions.permission_id'), nullable=False, unique=None, default=None)
     permission = relationship('Permission')
 
     rule_to_perm_id = Column('rule_to_perm_id', Integer(), ForeignKey('repo_to_perm.repo_to_perm_id'), nullable=False, unique=None, default=None)
     user_repo_to_perm = relationship('UserRepoToPerm')
 
     rule_order = Column('rule_order', Integer(), nullable=False)
     _branch_pattern = Column('branch_pattern', UnicodeText().with_variant(UnicodeText(2048), 'mysql'), default=u'*')  # glob
     _branch_hash = Column('branch_hash', UnicodeText().with_variant(UnicodeText(2048), 'mysql'))
 
     def __unicode__(self):
         return u'<UserBranchPermission(%s => %r)>' % (
             self.user_repo_to_perm, self.branch_pattern)
 
 
 class UserGroupToRepoBranchPermission(Base, _BaseBranchPerms):
     __tablename__ = 'user_group_to_repo_branch_permissions'
     __table_args__ = (
         base_table_args
     )
 
     branch_rule_id = Column('branch_rule_id', Integer(), primary_key=True)
 
     repository_id = Column('repository_id', Integer(), ForeignKey('repositories.repo_id'), nullable=False, unique=None, default=None)
     repo = relationship('Repository', backref='user_group_branch_perms')
 
     permission_id = Column('permission_id', Integer(), ForeignKey('permissions.permission_id'), nullable=False, unique=None, default=None)
     permission = relationship('Permission')
 
     rule_to_perm_id = Column('rule_to_perm_id', Integer(), ForeignKey('users_group_repo_to_perm.users_group_to_perm_id'), nullable=False, unique=None, default=None)
     user_group_repo_to_perm = relationship('UserGroupRepoToPerm')
 
     rule_order = Column('rule_order', Integer(), nullable=False)
     _branch_pattern = Column('branch_pattern', UnicodeText().with_variant(UnicodeText(2048), 'mysql'), default=u'*')  # glob
     _branch_hash = Column('branch_hash', UnicodeText().with_variant(UnicodeText(2048), 'mysql'))
 
     def __unicode__(self):
         return u'<UserBranchPermission(%s => %r)>' % (
             self.user_group_repo_to_perm, self.branch_pattern)
 
 
 class UserBookmark(Base, BaseModel):
     __tablename__ = 'user_bookmarks'
     __table_args__ = (
         UniqueConstraint('user_id', 'bookmark_repo_id'),
         UniqueConstraint('user_id', 'bookmark_repo_group_id'),
         UniqueConstraint('user_id', 'bookmark_position'),
         base_table_args
     )
 
     user_bookmark_id = Column("user_bookmark_id", Integer(), nullable=False, unique=True, default=None, primary_key=True)
     user_id = Column("user_id", Integer(), ForeignKey('users.user_id'), nullable=False, unique=None, default=None)
     position = Column("bookmark_position", Integer(), nullable=False)
     title = Column("bookmark_title", String(255), nullable=True, unique=None, default=None)
     redirect_url = Column("bookmark_redirect_url", String(10240), nullable=True, unique=None, default=None)
     created_on = Column("created_on", DateTime(timezone=False), nullable=False, default=datetime.datetime.now)
 
     bookmark_repo_id = Column("bookmark_repo_id", Integer(), ForeignKey("repositories.repo_id"), nullable=True, unique=None, default=None)
     bookmark_repo_group_id = Column("bookmark_repo_group_id", Integer(), ForeignKey("groups.group_id"), nullable=True, unique=None, default=None)
 
     user = relationship("User")
 
     repository = relationship("Repository")
     repository_group = relationship("RepoGroup")
 
     @classmethod
     def get_by_position_for_user(cls, position, user_id):
         return cls.query() \
             .filter(UserBookmark.user_id == user_id) \
             .filter(UserBookmark.position == position).scalar()
 
     @classmethod
     def get_bookmarks_for_user(cls, user_id, cache=True):
         bookmarks = cls.query() \
             .filter(UserBookmark.user_id == user_id) \
             .options(joinedload(UserBookmark.repository)) \
             .options(joinedload(UserBookmark.repository_group)) \
             .order_by(UserBookmark.position.asc())
 
         if cache:
             bookmarks = bookmarks.options(
                 FromCache("sql_cache_short", "get_user_{}_bookmarks".format(user_id))
             )
 
         return bookmarks.all()
 
     def __unicode__(self):
         return u'<UserBookmark(%s @ %r)>' % (self.position, self.redirect_url)
 
 
 class FileStore(Base, BaseModel):
     __tablename__ = 'file_store'
     __table_args__ = (
         base_table_args
     )
 
     file_store_id = Column('file_store_id', Integer(), primary_key=True)
     file_uid = Column('file_uid', String(1024), nullable=False)
     file_display_name = Column('file_display_name', UnicodeText().with_variant(UnicodeText(2048), 'mysql'), nullable=True)
     file_description = Column('file_description', UnicodeText().with_variant(UnicodeText(10240), 'mysql'), nullable=True)
     file_org_name = Column('file_org_name', UnicodeText().with_variant(UnicodeText(10240), 'mysql'), nullable=False)
 
     # sha256 hash
     file_hash = Column('file_hash', String(512), nullable=False)
     file_size = Column('file_size', BigInteger(), nullable=False)
 
     created_on = Column('created_on', DateTime(timezone=False), nullable=False, default=datetime.datetime.now)
     accessed_on = Column('accessed_on', DateTime(timezone=False), nullable=True)
     accessed_count = Column('accessed_count', Integer(), default=0)
 
     enabled = Column('enabled', Boolean(), nullable=False, default=True)
 
     # if repo/repo_group reference is set, check for permissions
     check_acl = Column('check_acl', Boolean(), nullable=False, default=True)
 
     # hidden defines an attachment that should be hidden from showing in artifact listing
     hidden = Column('hidden', Boolean(), nullable=False, default=False)
 
     user_id = Column('user_id', Integer(), ForeignKey('users.user_id'), nullable=False)
     upload_user = relationship('User', lazy='joined', primaryjoin='User.user_id==FileStore.user_id')
 
     file_metadata = relationship('FileStoreMetadata', lazy='joined')
 
     # scope limited to user, which requester have access to
     scope_user_id = Column(
         'scope_user_id', Integer(), ForeignKey('users.user_id'),
         nullable=True, unique=None, default=None)
     user = relationship('User', lazy='joined', primaryjoin='User.user_id==FileStore.scope_user_id')
 
     # scope limited to user group, which requester have access to
     scope_user_group_id = Column(
         'scope_user_group_id', Integer(), ForeignKey('users_groups.users_group_id'),
         nullable=True, unique=None, default=None)
     user_group = relationship('UserGroup', lazy='joined')
 
     # scope limited to repo, which requester have access to
     scope_repo_id = Column(
         'scope_repo_id', Integer(), ForeignKey('repositories.repo_id'),
         nullable=True, unique=None, default=None)
     repo = relationship('Repository', lazy='joined')
 
     # scope limited to repo group, which requester have access to
     scope_repo_group_id = Column(
         'scope_repo_group_id', Integer(), ForeignKey('groups.group_id'),
         nullable=True, unique=None, default=None)
     repo_group = relationship('RepoGroup', lazy='joined')
 
     @classmethod
     def get_by_store_uid(cls, file_store_uid, safe=False):
         if safe:
             return FileStore.query().filter(FileStore.file_uid == file_store_uid).first()
         else:
             return FileStore.query().filter(FileStore.file_uid == file_store_uid).scalar()
 
     @classmethod
     def create(cls, file_uid, filename, file_hash, file_size, file_display_name='',
                file_description='', enabled=True, hidden=False, check_acl=True,
                user_id=None, scope_user_id=None, scope_repo_id=None, scope_repo_group_id=None):
 
         store_entry = FileStore()
         store_entry.file_uid = file_uid
         store_entry.file_display_name = file_display_name
         store_entry.file_org_name = filename
         store_entry.file_size = file_size
         store_entry.file_hash = file_hash
         store_entry.file_description = file_description
 
         store_entry.check_acl = check_acl
         store_entry.enabled = enabled
         store_entry.hidden = hidden
 
         store_entry.user_id = user_id
         store_entry.scope_user_id = scope_user_id
         store_entry.scope_repo_id = scope_repo_id
         store_entry.scope_repo_group_id = scope_repo_group_id
 
         return store_entry
 
     @classmethod
     def store_metadata(cls, file_store_id, args, commit=True):
         file_store = FileStore.get(file_store_id)
         if file_store is None:
             return
 
         for section, key, value, value_type in args:
             has_key = FileStoreMetadata().query() \
                 .filter(FileStoreMetadata.file_store_id == file_store.file_store_id) \
                 .filter(FileStoreMetadata.file_store_meta_section == section) \
                 .filter(FileStoreMetadata.file_store_meta_key == key) \
                 .scalar()
             if has_key:
                 msg = 'key `{}` already defined under section `{}` for this file.'\
                     .format(key, section)
                 raise ArtifactMetadataDuplicate(msg, err_section=section, err_key=key)
 
             # NOTE(marcink): raises ArtifactMetadataBadValueType
             FileStoreMetadata.valid_value_type(value_type)
 
             meta_entry = FileStoreMetadata()
             meta_entry.file_store = file_store
             meta_entry.file_store_meta_section = section
             meta_entry.file_store_meta_key = key
             meta_entry.file_store_meta_value_type = value_type
             meta_entry.file_store_meta_value = value
 
             Session().add(meta_entry)
 
         try:
             if commit:
                 Session().commit()
         except IntegrityError:
             Session().rollback()
             raise ArtifactMetadataDuplicate('Duplicate section/key found for this file.')
 
     @classmethod
     def bump_access_counter(cls, file_uid, commit=True):
         FileStore().query()\
             .filter(FileStore.file_uid == file_uid)\
             .update({FileStore.accessed_count: (FileStore.accessed_count + 1),
                      FileStore.accessed_on: datetime.datetime.now()})
         if commit:
             Session().commit()
 
     def __json__(self):
         data = {
             'filename': self.file_display_name,
             'filename_org': self.file_org_name,
             'file_uid': self.file_uid,
             'description': self.file_description,
             'hidden': self.hidden,
             'size': self.file_size,
             'created_on': self.created_on,
             'uploaded_by': self.upload_user.get_api_data(details='basic'),
             'downloaded_times': self.accessed_count,
             'sha256': self.file_hash,
             'metadata': self.file_metadata,
         }
 
         return data
 
     def __repr__(self):
         return '<FileStore({})>'.format(self.file_store_id)
 
 
 class FileStoreMetadata(Base, BaseModel):
     __tablename__ = 'file_store_metadata'
     __table_args__ = (
         UniqueConstraint('file_store_id', 'file_store_meta_section_hash', 'file_store_meta_key_hash'),
         Index('file_store_meta_section_idx', 'file_store_meta_section', mysql_length=255),
         Index('file_store_meta_key_idx', 'file_store_meta_key', mysql_length=255),
         base_table_args
     )
     SETTINGS_TYPES = {
         'str': safe_str,
         'int': safe_int,
         'unicode': safe_unicode,
         'bool': str2bool,
         'list': functools.partial(aslist, sep=',')
     }
 
     file_store_meta_id = Column(
         "file_store_meta_id", Integer(), nullable=False, unique=True, default=None,
         primary_key=True)
     _file_store_meta_section = Column(
         "file_store_meta_section", UnicodeText().with_variant(UnicodeText(1024), 'mysql'),
         nullable=True, unique=None, default=None)
     _file_store_meta_section_hash = Column(
         "file_store_meta_section_hash", String(255),
         nullable=True, unique=None, default=None)
     _file_store_meta_key = Column(
         "file_store_meta_key", UnicodeText().with_variant(UnicodeText(1024), 'mysql'),
         nullable=True, unique=None, default=None)
     _file_store_meta_key_hash = Column(
         "file_store_meta_key_hash", String(255), nullable=True, unique=None, default=None)
     _file_store_meta_value = Column(
         "file_store_meta_value", UnicodeText().with_variant(UnicodeText(20480), 'mysql'),
         nullable=True, unique=None, default=None)
     _file_store_meta_value_type = Column(
         "file_store_meta_value_type", String(255), nullable=True, unique=None,
         default='unicode')
 
     file_store_id = Column(
         'file_store_id', Integer(), ForeignKey('file_store.file_store_id'),
         nullable=True, unique=None, default=None)
 
     file_store = relationship('FileStore', lazy='joined')
 
     @classmethod
     def valid_value_type(cls, value):
         if value.split('.')[0] not in cls.SETTINGS_TYPES:
             raise ArtifactMetadataBadValueType(
                 'value_type must be one of %s got %s' % (cls.SETTINGS_TYPES.keys(), value))
 
     @hybrid_property
     def file_store_meta_section(self):
         return self._file_store_meta_section
 
     @file_store_meta_section.setter
     def file_store_meta_section(self, value):
         self._file_store_meta_section = value
         self._file_store_meta_section_hash = _hash_key(value)
 
     @hybrid_property
     def file_store_meta_key(self):
         return self._file_store_meta_key
 
     @file_store_meta_key.setter
     def file_store_meta_key(self, value):
         self._file_store_meta_key = value
         self._file_store_meta_key_hash = _hash_key(value)
 
     @hybrid_property
     def file_store_meta_value(self):
         val = self._file_store_meta_value
 
         if self._file_store_meta_value_type:
             # e.g unicode.encrypted == unicode
             _type = self._file_store_meta_value_type.split('.')[0]
             # decode the encrypted value if it's encrypted field type
             if '.encrypted' in self._file_store_meta_value_type:
                 cipher = EncryptedTextValue()
                 val = safe_unicode(cipher.process_result_value(val, None))
             # do final type conversion
             converter = self.SETTINGS_TYPES.get(_type) or self.SETTINGS_TYPES['unicode']
             val = converter(val)
 
         return val
 
     @file_store_meta_value.setter
     def file_store_meta_value(self, val):
         val = safe_unicode(val)
         # encode the encrypted value
         if '.encrypted' in self.file_store_meta_value_type:
             cipher = EncryptedTextValue()
             val = safe_unicode(cipher.process_bind_param(val, None))
         self._file_store_meta_value = val
 
     @hybrid_property
     def file_store_meta_value_type(self):
         return self._file_store_meta_value_type
 
     @file_store_meta_value_type.setter
     def file_store_meta_value_type(self, val):
         # e.g unicode.encrypted
         self.valid_value_type(val)
         self._file_store_meta_value_type = val
 
     def __json__(self):
         data = {
             'artifact': self.file_store.file_uid,
             'section': self.file_store_meta_section,
             'key': self.file_store_meta_key,
             'value': self.file_store_meta_value,
         }
 
         return data
 
     def __repr__(self):
         return '<%s[%s]%s=>%s]>' % (self.__class__.__name__, self.file_store_meta_section,
                                     self.file_store_meta_key, self.file_store_meta_value)
 
 
 class DbMigrateVersion(Base, BaseModel):
     __tablename__ = 'db_migrate_version'
     __table_args__ = (
         base_table_args,
     )
 
     repository_id = Column('repository_id', String(250), primary_key=True)
     repository_path = Column('repository_path', Text)
     version = Column('version', Integer)
 
     @classmethod
     def set_version(cls, version):
         """
         Helper for forcing a different version, usually for debugging purposes via ishell.
         """
         ver = DbMigrateVersion.query().first()
         ver.version = version
         Session().commit()
 
 
 class DbSession(Base, BaseModel):
     __tablename__ = 'db_session'
     __table_args__ = (
         base_table_args,
     )
 
     def __repr__(self):
         return '<DB:DbSession({})>'.format(self.id)
 
     id = Column('id', Integer())
     namespace = Column('namespace', String(255), primary_key=True)
     accessed = Column('accessed', DateTime, nullable=False)
     created = Column('created', DateTime, nullable=False)
     data = Column('data', PickleType, nullable=False)

rhodecode/model/forms.py

@@ -1,631 +1,640 b''
 # -*- coding: utf-8 -*-
 
 # Copyright (C) 2010-2020 RhodeCode GmbH
 #
 # This program is free software: you can redistribute it and/or modify
 # it under the terms of the GNU Affero General Public License, version 3
 # (only), as published by the Free Software Foundation.
 #
 # 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 Affero General Public License
 # along with this program.  If not, see <http://www.gnu.org/licenses/>.
 #
 # This program is dual-licensed. If you wish to learn more about the
 # RhodeCode Enterprise Edition, including its added features, Support services,
 # and proprietary license terms, please see https://rhodecode.com/licenses/
 
 """
 this is forms validation classes
 http://formencode.org/module-formencode.validators.html
 for list off all availible validators
 
 we can create our own validators
 
 The table below outlines the options which can be used in a schema in addition to the validators themselves
 pre_validators          []     These validators will be applied before the schema
 chained_validators      []     These validators will be applied after the schema
 allow_extra_fields      False     If True, then it is not an error when keys that aren't associated with a validator are present
 filter_extra_fields     False     If True, then keys that aren't associated with a validator are removed
 if_key_missing          NoDefault If this is given, then any keys that aren't available but are expected will be replaced with this value (and then validated). This does not override a present .if_missing attribute on validators. NoDefault is a special FormEncode class to mean that no default values has been specified and therefore missing keys shouldn't take a default value.
 ignore_key_missing      False     If True, then missing keys will be missing in the result, if the validator doesn't have .if_missing on it already
 
 
 <name> = formencode.validators.<name of validator>
 <name> must equal form name
 list=[1,2,3,4,5]
 for SELECT use formencode.All(OneOf(list), Int())
 
 """
 
 import deform
 import logging
 import formencode
 
 from pkg_resources import resource_filename
 from formencode import All, Pipe
 
 from pyramid.threadlocal import get_current_request
 
 from rhodecode import BACKENDS
 from rhodecode.lib import helpers
 from rhodecode.model import validators as v
 
 log = logging.getLogger(__name__)
 
 
 deform_templates = resource_filename('deform', 'templates')
 rhodecode_templates = resource_filename('rhodecode', 'templates/forms')
 search_path = (rhodecode_templates, deform_templates)
 
 
 class RhodecodeFormZPTRendererFactory(deform.ZPTRendererFactory):
     """ Subclass of ZPTRendererFactory to add rhodecode context variables """
     def __call__(self, template_name, **kw):
         kw['h'] = helpers
         kw['request'] = get_current_request()
         return self.load(template_name)(**kw)
 
 
 form_renderer = RhodecodeFormZPTRendererFactory(search_path)
 deform.Form.set_default_renderer(form_renderer)
 
 
 def LoginForm(localizer):
     _ = localizer
 
     class _LoginForm(formencode.Schema):
         allow_extra_fields = True
         filter_extra_fields = True
         username = v.UnicodeString(
             strip=True,
             min=1,
             not_empty=True,
             messages={
                 'empty': _(u'Please enter a login'),
                 'tooShort': _(u'Enter a value %(min)i characters long or more')
             }
         )
 
         password = v.UnicodeString(
             strip=False,
             min=3,
             max=72,
             not_empty=True,
             messages={
                 'empty': _(u'Please enter a password'),
                 'tooShort': _(u'Enter %(min)i characters or more')}
         )
 
         remember = v.StringBoolean(if_missing=False)
 
         chained_validators = [v.ValidAuth(localizer)]
     return _LoginForm
 
 
 def UserForm(localizer, edit=False, available_languages=None, old_data=None):
     old_data = old_data or {}
     available_languages = available_languages or []
     _ = localizer
 
     class _UserForm(formencode.Schema):
         allow_extra_fields = True
         filter_extra_fields = True
         username = All(v.UnicodeString(strip=True, min=1, not_empty=True),
                        v.ValidUsername(localizer, edit, old_data))
         if edit:
             new_password = All(
                 v.ValidPassword(localizer),
                 v.UnicodeString(strip=False, min=6, max=72, not_empty=False)
             )
             password_confirmation = All(
                 v.ValidPassword(localizer),
                 v.UnicodeString(strip=False, min=6, max=72, not_empty=False),
             )
             admin = v.StringBoolean(if_missing=False)
         else:
             password = All(
                 v.ValidPassword(localizer),
                 v.UnicodeString(strip=False, min=6, max=72, not_empty=True)
             )
             password_confirmation = All(
                 v.ValidPassword(localizer),
                 v.UnicodeString(strip=False, min=6, max=72, not_empty=False)
             )
 
         password_change = v.StringBoolean(if_missing=False)
         create_repo_group = v.StringBoolean(if_missing=False)
 
         active = v.StringBoolean(if_missing=False)
         firstname = v.UnicodeString(strip=True, min=1, not_empty=False)
         lastname = v.UnicodeString(strip=True, min=1, not_empty=False)
         email = All(v.UniqSystemEmail(localizer, old_data), v.Email(not_empty=True))
         description = v.UnicodeString(strip=True, min=1, max=250, not_empty=False,
                                       if_missing='')
         extern_name = v.UnicodeString(strip=True)
         extern_type = v.UnicodeString(strip=True)
         language = v.OneOf(available_languages, hideList=False,
                            testValueList=True, if_missing=None)
         chained_validators = [v.ValidPasswordsMatch(localizer)]
     return _UserForm
 
 
 def UserGroupForm(localizer, edit=False, old_data=None, allow_disabled=False):
     old_data = old_data or {}
     _ = localizer
 
     class _UserGroupForm(formencode.Schema):
         allow_extra_fields = True
         filter_extra_fields = True
 
         users_group_name = All(
             v.UnicodeString(strip=True, min=1, not_empty=True),
             v.ValidUserGroup(localizer, edit, old_data)
         )
         user_group_description = v.UnicodeString(strip=True, min=1,
                                                  not_empty=False)
 
         users_group_active = v.StringBoolean(if_missing=False)
 
         if edit:
             # this is user group owner
             user = All(
                 v.UnicodeString(not_empty=True),
                 v.ValidRepoUser(localizer, allow_disabled))
     return _UserGroupForm
 
 
 def RepoGroupForm(localizer, edit=False, old_data=None, available_groups=None,
                   can_create_in_root=False, allow_disabled=False):
     _ = localizer
     old_data = old_data or {}
     available_groups = available_groups or []
 
     class _RepoGroupForm(formencode.Schema):
         allow_extra_fields = True
         filter_extra_fields = False
 
         group_name = All(v.UnicodeString(strip=True, min=1, not_empty=True),
                          v.SlugifyName(localizer),)
         group_description = v.UnicodeString(strip=True, min=1,
                                             not_empty=False)
         group_copy_permissions = v.StringBoolean(if_missing=False)
 
         group_parent_id = v.OneOf(available_groups, hideList=False,
                                   testValueList=True, not_empty=True)
         enable_locking = v.StringBoolean(if_missing=False)
         chained_validators = [
             v.ValidRepoGroup(localizer, edit, old_data, can_create_in_root)]
 
         if edit:
             # this is repo group owner
             user = All(
                 v.UnicodeString(not_empty=True),
                 v.ValidRepoUser(localizer, allow_disabled))
     return _RepoGroupForm
 
 
 def RegisterForm(localizer, edit=False, old_data=None):
     _ = localizer
     old_data = old_data or {}
 
     class _RegisterForm(formencode.Schema):
         allow_extra_fields = True
         filter_extra_fields = True
         username = All(
             v.ValidUsername(localizer, edit, old_data),
             v.UnicodeString(strip=True, min=1, not_empty=True)
         )
         password = All(
             v.ValidPassword(localizer),
             v.UnicodeString(strip=False, min=6, max=72, not_empty=True)
         )
         password_confirmation = All(
             v.ValidPassword(localizer),
             v.UnicodeString(strip=False, min=6, max=72, not_empty=True)
         )
         active = v.StringBoolean(if_missing=False)
         firstname = v.UnicodeString(strip=True, min=1, not_empty=False)
         lastname = v.UnicodeString(strip=True, min=1, not_empty=False)
         email = All(v.UniqSystemEmail(localizer, old_data), v.Email(not_empty=True))
 
         chained_validators = [v.ValidPasswordsMatch(localizer)]
     return _RegisterForm
 
 
 def PasswordResetForm(localizer):
     _ = localizer
 
     class _PasswordResetForm(formencode.Schema):
         allow_extra_fields = True
         filter_extra_fields = True
         email = All(v.ValidSystemEmail(localizer), v.Email(not_empty=True))
     return _PasswordResetForm
 
 
 def RepoForm(localizer, edit=False, old_data=None, repo_groups=None, allow_disabled=False):
     _ = localizer
     old_data = old_data or {}
     repo_groups = repo_groups or []
     supported_backends = BACKENDS.keys()
 
     class _RepoForm(formencode.Schema):
         allow_extra_fields = True
         filter_extra_fields = False
         repo_name = All(v.UnicodeString(strip=True, min=1, not_empty=True),
                         v.SlugifyName(localizer), v.CannotHaveGitSuffix(localizer))
         repo_group = All(v.CanWriteGroup(localizer, old_data),
                          v.OneOf(repo_groups, hideList=True))
         repo_type = v.OneOf(supported_backends, required=False,
                             if_missing=old_data.get('repo_type'))
         repo_description = v.UnicodeString(strip=True, min=1, not_empty=False)
         repo_private = v.StringBoolean(if_missing=False)
         repo_copy_permissions = v.StringBoolean(if_missing=False)
         clone_uri = All(v.UnicodeString(strip=True, min=1, not_empty=False))
 
         repo_enable_statistics = v.StringBoolean(if_missing=False)
         repo_enable_downloads = v.StringBoolean(if_missing=False)
         repo_enable_locking = v.StringBoolean(if_missing=False)
 
         if edit:
             # this is repo owner
             user = All(
                 v.UnicodeString(not_empty=True),
                 v.ValidRepoUser(localizer, allow_disabled))
             clone_uri_change = v.UnicodeString(
                 not_empty=False, if_missing=v.Missing)
 
         chained_validators = [v.ValidCloneUri(localizer),
                               v.ValidRepoName(localizer, edit, old_data)]
     return _RepoForm
 
 
 def RepoPermsForm(localizer):
     _ = localizer
 
     class _RepoPermsForm(formencode.Schema):
         allow_extra_fields = True
         filter_extra_fields = False
         chained_validators = [v.ValidPerms(localizer, type_='repo')]
     return _RepoPermsForm
 
 
 def RepoGroupPermsForm(localizer, valid_recursive_choices):
     _ = localizer
 
     class _RepoGroupPermsForm(formencode.Schema):
         allow_extra_fields = True
         filter_extra_fields = False
         recursive = v.OneOf(valid_recursive_choices)
         chained_validators = [v.ValidPerms(localizer, type_='repo_group')]
     return _RepoGroupPermsForm
 
 
 def UserGroupPermsForm(localizer):
     _ = localizer
 
     class _UserPermsForm(formencode.Schema):
         allow_extra_fields = True
         filter_extra_fields = False
         chained_validators = [v.ValidPerms(localizer, type_='user_group')]
     return _UserPermsForm
 
 
 def RepoFieldForm(localizer):
     _ = localizer
 
     class _RepoFieldForm(formencode.Schema):
         filter_extra_fields = True
         allow_extra_fields = True
 
         new_field_key = All(v.FieldKey(localizer),
                             v.UnicodeString(strip=True, min=3, not_empty=True))
         new_field_value = v.UnicodeString(not_empty=False, if_missing=u'')
         new_field_type = v.OneOf(['str', 'unicode', 'list', 'tuple'],
                                  if_missing='str')
         new_field_label = v.UnicodeString(not_empty=False)
         new_field_desc = v.UnicodeString(not_empty=False)
     return _RepoFieldForm
 
 
 def RepoForkForm(localizer, edit=False, old_data=None,
                  supported_backends=BACKENDS.keys(), repo_groups=None):
     _ = localizer
     old_data = old_data or {}
     repo_groups = repo_groups or []
 
     class _RepoForkForm(formencode.Schema):
         allow_extra_fields = True
         filter_extra_fields = False
         repo_name = All(v.UnicodeString(strip=True, min=1, not_empty=True),
                         v.SlugifyName(localizer))
         repo_group = All(v.CanWriteGroup(localizer, ),
                          v.OneOf(repo_groups, hideList=True))
         repo_type = All(v.ValidForkType(localizer, old_data), v.OneOf(supported_backends))
         description = v.UnicodeString(strip=True, min=1, not_empty=True)
         private = v.StringBoolean(if_missing=False)
         copy_permissions = v.StringBoolean(if_missing=False)
         fork_parent_id = v.UnicodeString()
         chained_validators = [v.ValidForkName(localizer, edit, old_data)]
     return _RepoForkForm
 
 
 def ApplicationSettingsForm(localizer):
     _ = localizer
 
     class _ApplicationSettingsForm(formencode.Schema):
         allow_extra_fields = True
         filter_extra_fields = False
         rhodecode_title = v.UnicodeString(strip=True, max=40, not_empty=False)
         rhodecode_realm = v.UnicodeString(strip=True, min=1, not_empty=True)
         rhodecode_pre_code = v.UnicodeString(strip=True, min=1, not_empty=False)
         rhodecode_post_code = v.UnicodeString(strip=True, min=1, not_empty=False)
         rhodecode_captcha_public_key = v.UnicodeString(strip=True, min=1, not_empty=False)
         rhodecode_captcha_private_key = v.UnicodeString(strip=True, min=1, not_empty=False)
         rhodecode_create_personal_repo_group = v.StringBoolean(if_missing=False)
         rhodecode_personal_repo_group_pattern = v.UnicodeString(strip=True, min=1, not_empty=False)
     return _ApplicationSettingsForm
 
 
 def ApplicationVisualisationForm(localizer):
     from rhodecode.model.db import Repository
     _ = localizer
 
     class _ApplicationVisualisationForm(formencode.Schema):
         allow_extra_fields = True
         filter_extra_fields = False
         rhodecode_show_public_icon = v.StringBoolean(if_missing=False)
         rhodecode_show_private_icon = v.StringBoolean(if_missing=False)
         rhodecode_stylify_metatags = v.StringBoolean(if_missing=False)
 
         rhodecode_repository_fields = v.StringBoolean(if_missing=False)
         rhodecode_lightweight_journal = v.StringBoolean(if_missing=False)
         rhodecode_dashboard_items = v.Int(min=5, not_empty=True)
         rhodecode_admin_grid_items = v.Int(min=5, not_empty=True)
         rhodecode_show_version = v.StringBoolean(if_missing=False)
         rhodecode_use_gravatar = v.StringBoolean(if_missing=False)
         rhodecode_markup_renderer = v.OneOf(['markdown', 'rst'])
         rhodecode_gravatar_url = v.UnicodeString(min=3)
         rhodecode_clone_uri_tmpl = v.UnicodeString(not_empty=False, if_empty=Repository.DEFAULT_CLONE_URI)
         rhodecode_clone_uri_ssh_tmpl = v.UnicodeString(not_empty=False, if_empty=Repository.DEFAULT_CLONE_URI_SSH)
         rhodecode_support_url = v.UnicodeString()
         rhodecode_show_revision_number = v.StringBoolean(if_missing=False)
         rhodecode_show_sha_length = v.Int(min=4, not_empty=True)
     return _ApplicationVisualisationForm
 
 
 class _BaseVcsSettingsForm(formencode.Schema):
 
     allow_extra_fields = True
     filter_extra_fields = False
     hooks_changegroup_repo_size = v.StringBoolean(if_missing=False)
     hooks_changegroup_push_logger = v.StringBoolean(if_missing=False)
     hooks_outgoing_pull_logger = v.StringBoolean(if_missing=False)
 
     # PR/Code-review
     rhodecode_pr_merge_enabled = v.StringBoolean(if_missing=False)
     rhodecode_use_outdated_comments = v.StringBoolean(if_missing=False)
 
     # hg
     extensions_largefiles = v.StringBoolean(if_missing=False)
     extensions_evolve = v.StringBoolean(if_missing=False)
     phases_publish = v.StringBoolean(if_missing=False)
 
     rhodecode_hg_use_rebase_for_merging = v.StringBoolean(if_missing=False)
     rhodecode_hg_close_branch_before_merging = v.StringBoolean(if_missing=False)
 
     # git
     vcs_git_lfs_enabled = v.StringBoolean(if_missing=False)
     rhodecode_git_use_rebase_for_merging = v.StringBoolean(if_missing=False)
     rhodecode_git_close_branch_before_merging = v.StringBoolean(if_missing=False)
 
     # svn
     vcs_svn_proxy_http_requests_enabled = v.StringBoolean(if_missing=False)
     vcs_svn_proxy_http_server_url = v.UnicodeString(strip=True, if_missing=None)
 
     # cache
     rhodecode_diff_cache = v.StringBoolean(if_missing=False)
 
 
 def ApplicationUiSettingsForm(localizer):
     _ = localizer
 
     class _ApplicationUiSettingsForm(_BaseVcsSettingsForm):
         web_push_ssl = v.StringBoolean(if_missing=False)
         paths_root_path = All(
             v.ValidPath(localizer),
             v.UnicodeString(strip=True, min=1, not_empty=True)
         )
         largefiles_usercache = All(
             v.ValidPath(localizer),
             v.UnicodeString(strip=True, min=2, not_empty=True))
         vcs_git_lfs_store_location = All(
             v.ValidPath(localizer),
             v.UnicodeString(strip=True, min=2, not_empty=True))
         extensions_hgsubversion = v.StringBoolean(if_missing=False)
         extensions_hggit = v.StringBoolean(if_missing=False)
         new_svn_branch = v.ValidSvnPattern(localizer, section='vcs_svn_branch')
         new_svn_tag = v.ValidSvnPattern(localizer, section='vcs_svn_tag')
     return _ApplicationUiSettingsForm
 
 
 def RepoVcsSettingsForm(localizer, repo_name):
     _ = localizer
 
     class _RepoVcsSettingsForm(_BaseVcsSettingsForm):
         inherit_global_settings = v.StringBoolean(if_missing=False)
         new_svn_branch = v.ValidSvnPattern(localizer,
             section='vcs_svn_branch', repo_name=repo_name)
         new_svn_tag = v.ValidSvnPattern(localizer,
             section='vcs_svn_tag', repo_name=repo_name)
     return _RepoVcsSettingsForm
 
 
 def LabsSettingsForm(localizer):
     _ = localizer
 
     class _LabSettingsForm(formencode.Schema):
         allow_extra_fields = True
         filter_extra_fields = False
     return _LabSettingsForm
 
 
 def ApplicationPermissionsForm(
         localizer, register_choices, password_reset_choices,
         extern_activate_choices):
     _ = localizer
 
     class _DefaultPermissionsForm(formencode.Schema):
         allow_extra_fields = True
         filter_extra_fields = True
 
         anonymous = v.StringBoolean(if_missing=False)
         default_register = v.OneOf(register_choices)
         default_register_message = v.UnicodeString()
         default_password_reset = v.OneOf(password_reset_choices)
         default_extern_activate = v.OneOf(extern_activate_choices)
     return _DefaultPermissionsForm
 
 
 def ObjectPermissionsForm(localizer, repo_perms_choices, group_perms_choices,
                           user_group_perms_choices):
     _ = localizer
 
     class _ObjectPermissionsForm(formencode.Schema):
         allow_extra_fields = True
         filter_extra_fields = True
         overwrite_default_repo = v.StringBoolean(if_missing=False)
         overwrite_default_group = v.StringBoolean(if_missing=False)
         overwrite_default_user_group = v.StringBoolean(if_missing=False)
 
         default_repo_perm = v.OneOf(repo_perms_choices)
         default_group_perm = v.OneOf(group_perms_choices)
         default_user_group_perm = v.OneOf(user_group_perms_choices)
 
     return _ObjectPermissionsForm
 
 
 def BranchPermissionsForm(localizer, branch_perms_choices):
     _ = localizer
 
     class _BranchPermissionsForm(formencode.Schema):
         allow_extra_fields = True
         filter_extra_fields = True
         overwrite_default_branch = v.StringBoolean(if_missing=False)
         default_branch_perm = v.OneOf(branch_perms_choices)
 
     return _BranchPermissionsForm
 
 
 def UserPermissionsForm(localizer, create_choices, create_on_write_choices,
                         repo_group_create_choices, user_group_create_choices,
                         fork_choices, inherit_default_permissions_choices):
     _ = localizer
 
     class _DefaultPermissionsForm(formencode.Schema):
         allow_extra_fields = True
         filter_extra_fields = True
 
         anonymous = v.StringBoolean(if_missing=False)
 
         default_repo_create = v.OneOf(create_choices)
         default_repo_create_on_write = v.OneOf(create_on_write_choices)
         default_user_group_create = v.OneOf(user_group_create_choices)
         default_repo_group_create = v.OneOf(repo_group_create_choices)
         default_fork_create = v.OneOf(fork_choices)
         default_inherit_default_permissions = v.OneOf(inherit_default_permissions_choices)
     return _DefaultPermissionsForm
 
 
 def UserIndividualPermissionsForm(localizer):
     _ = localizer
 
     class _DefaultPermissionsForm(formencode.Schema):
         allow_extra_fields = True
         filter_extra_fields = True
 
         inherit_default_permissions = v.StringBoolean(if_missing=False)
     return _DefaultPermissionsForm
 
 
 def DefaultsForm(localizer, edit=False, old_data=None, supported_backends=BACKENDS.keys()):
     _ = localizer
     old_data = old_data or {}
 
     class _DefaultsForm(formencode.Schema):
         allow_extra_fields = True
         filter_extra_fields = True
         default_repo_type = v.OneOf(supported_backends)
         default_repo_private = v.StringBoolean(if_missing=False)
         default_repo_enable_statistics = v.StringBoolean(if_missing=False)
         default_repo_enable_downloads = v.StringBoolean(if_missing=False)
         default_repo_enable_locking = v.StringBoolean(if_missing=False)
     return _DefaultsForm
 
 
 def AuthSettingsForm(localizer):
     _ = localizer
 
     class _AuthSettingsForm(formencode.Schema):
         allow_extra_fields = True
         filter_extra_fields = True
         auth_plugins = All(v.ValidAuthPlugins(localizer),
                            v.UniqueListFromString(localizer)(not_empty=True))
     return _AuthSettingsForm
 
 
 def UserExtraEmailForm(localizer):
     _ = localizer
 
     class _UserExtraEmailForm(formencode.Schema):
         email = All(v.UniqSystemEmail(localizer), v.Email(not_empty=True))
     return _UserExtraEmailForm
 
 
 def UserExtraIpForm(localizer):
     _ = localizer
 
     class _UserExtraIpForm(formencode.Schema):
         ip = v.ValidIp(localizer)(not_empty=True)
     return _UserExtraIpForm
 
 
 def PullRequestForm(localizer, repo_id):
     _ = localizer
 
     class ReviewerForm(formencode.Schema):
         user_id = v.Int(not_empty=True)
         reasons = All()
         rules = All(v.UniqueList(localizer, convert=int)())
         mandatory = v.StringBoolean()
+        role = v.String(if_missing='reviewer')
+
+    class ObserverForm(formencode.Schema):
+        user_id = v.Int(not_empty=True)
+        reasons = All()
+        rules = All(v.UniqueList(localizer, convert=int)())
+        mandatory = v.StringBoolean()
+        role = v.String(if_missing='observer')
 
     class _PullRequestForm(formencode.Schema):
         allow_extra_fields = True
         filter_extra_fields = True
 
         common_ancestor = v.UnicodeString(strip=True, required=True)
         source_repo = v.UnicodeString(strip=True, required=True)
         source_ref = v.UnicodeString(strip=True, required=True)
         target_repo = v.UnicodeString(strip=True, required=True)
         target_ref = v.UnicodeString(strip=True, required=True)
         revisions = All(#v.NotReviewedRevisions(localizer, repo_id)(),
                         v.UniqueList(localizer)(not_empty=True))
         review_members = formencode.ForEach(ReviewerForm())
+        observer_members = formencode.ForEach(ObserverForm())
         pullrequest_title = v.UnicodeString(strip=True, required=True, min=1, max=255)
         pullrequest_desc = v.UnicodeString(strip=True, required=False)
         description_renderer = v.UnicodeString(strip=True, required=False)
 
     return _PullRequestForm
 
 
 def IssueTrackerPatternsForm(localizer):
     _ = localizer
 
     class _IssueTrackerPatternsForm(formencode.Schema):
         allow_extra_fields = True
         filter_extra_fields = False
         chained_validators = [v.ValidPattern(localizer)]
     return _IssueTrackerPatternsForm

rhodecode/model/pull_request.py

@@ -1,2072 +1,2201 b''
 # -*- coding: utf-8 -*-
 
 # Copyright (C) 2012-2020 RhodeCode GmbH
 #
 # This program is free software: you can redistribute it and/or modify
 # it under the terms of the GNU Affero General Public License, version 3
 # (only), as published by the Free Software Foundation.
 #
 # 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 Affero General Public License
 # along with this program.  If not, see <http://www.gnu.org/licenses/>.
 #
 # This program is dual-licensed. If you wish to learn more about the
 # RhodeCode Enterprise Edition, including its added features, Support services,
 # and proprietary license terms, please see https://rhodecode.com/licenses/
 
 
 """
 pull request model for RhodeCode
 """
 
 
 import json
 import logging
 import os
 
 import datetime
 import urllib
 import collections
 
 from pyramid import compat
 from pyramid.threadlocal import get_current_request
 
 from rhodecode.lib.vcs.nodes import FileNode
 from rhodecode.translation import lazy_ugettext
 from rhodecode.lib import helpers as h, hooks_utils, diffs
 from rhodecode.lib import audit_logger
 from rhodecode.lib.compat import OrderedDict
 from rhodecode.lib.hooks_daemon import prepare_callback_daemon
 from rhodecode.lib.markup_renderer import (
     DEFAULT_COMMENTS_RENDERER, RstTemplateRenderer)
 from rhodecode.lib.utils2 import (
     safe_unicode, safe_str, md5_safe, AttributeDict, safe_int,
     get_current_rhodecode_user)
 from rhodecode.lib.vcs.backends.base import (
     Reference, MergeResponse, MergeFailureReason, UpdateFailureReason,
     TargetRefMissing, SourceRefMissing)
 from rhodecode.lib.vcs.conf import settings as vcs_settings
 from rhodecode.lib.vcs.exceptions import (
     CommitDoesNotExistError, EmptyRepositoryError)
 from rhodecode.model import BaseModel
 from rhodecode.model.changeset_status import ChangesetStatusModel
 from rhodecode.model.comment import CommentsModel
 from rhodecode.model.db import (
     or_, String, cast, PullRequest, PullRequestReviewers, ChangesetStatus,
     PullRequestVersion, ChangesetComment, Repository, RepoReviewRule, User)
 from rhodecode.model.meta import Session
 from rhodecode.model.notification import NotificationModel, \
     EmailNotificationModel
 from rhodecode.model.scm import ScmModel
 from rhodecode.model.settings import VcsSettingsModel
 
 
 log = logging.getLogger(__name__)
 
 
 # Data structure to hold the response data when updating commits during a pull
 # request update.
 class UpdateResponse(object):
 
     def __init__(self, executed, reason, new, old, common_ancestor_id,
                  commit_changes, source_changed, target_changed):
 
         self.executed = executed
         self.reason = reason
         self.new = new
         self.old = old
         self.common_ancestor_id = common_ancestor_id
         self.changes = commit_changes
         self.source_changed = source_changed
         self.target_changed = target_changed
 
 
 def get_diff_info(
         source_repo, source_ref, target_repo, target_ref, get_authors=False,
         get_commit_authors=True):
     """
     Calculates detailed diff information for usage in preview of creation of a pull-request.
     This is also used for default reviewers logic
     """
 
     source_scm = source_repo.scm_instance()
     target_scm = target_repo.scm_instance()
 
     ancestor_id = target_scm.get_common_ancestor(target_ref, source_ref, source_scm)
     if not ancestor_id:
         raise ValueError(
             'cannot calculate diff info without a common ancestor. '
             'Make sure both repositories are related, and have a common forking commit.')
 
     # case here is that want a simple diff without incoming commits,
     # previewing what will be merged based only on commits in the source.
     log.debug('Using ancestor %s as source_ref instead of %s',
               ancestor_id, source_ref)
 
     # source of changes now is the common ancestor
     source_commit = source_scm.get_commit(commit_id=ancestor_id)
     # target commit becomes the source ref as it is the last commit
     # for diff generation this logic gives proper diff
     target_commit = source_scm.get_commit(commit_id=source_ref)
 
     vcs_diff = \
         source_scm.get_diff(commit1=source_commit, commit2=target_commit,
                             ignore_whitespace=False, context=3)
 
     diff_processor = diffs.DiffProcessor(
         vcs_diff, format='newdiff', diff_limit=None,
         file_limit=None, show_full_diff=True)
 
     _parsed = diff_processor.prepare()
 
     all_files = []
     all_files_changes = []
     changed_lines = {}
     stats = [0, 0]
     for f in _parsed:
         all_files.append(f['filename'])
         all_files_changes.append({
             'filename': f['filename'],
             'stats': f['stats']
         })
         stats[0] += f['stats']['added']
         stats[1] += f['stats']['deleted']
 
         changed_lines[f['filename']] = []
         if len(f['chunks']) < 2:
             continue
         # first line is "context" information
         for chunks in f['chunks'][1:]:
             for chunk in chunks['lines']:
                 if chunk['action'] not in ('del', 'mod'):
                     continue
                 changed_lines[f['filename']].append(chunk['old_lineno'])
 
     commit_authors = []
     user_counts = {}
     email_counts = {}
     author_counts = {}
     _commit_cache = {}
 
     commits = []
     if get_commit_authors:
         commits = target_scm.compare(
             target_ref, source_ref, source_scm, merge=True,
             pre_load=["author"])
 
         for commit in commits:
             user = User.get_from_cs_author(commit.author)
             if user and user not in commit_authors:
                 commit_authors.append(user)
 
     # lines
     if get_authors:
         target_commit = source_repo.get_commit(ancestor_id)
 
         for fname, lines in changed_lines.items():
             try:
                 node = target_commit.get_node(fname)
             except Exception:
                 continue
 
             if not isinstance(node, FileNode):
                 continue
 
             for annotation in node.annotate:
                 line_no, commit_id, get_commit_func, line_text = annotation
                 if line_no in lines:
                     if commit_id not in _commit_cache:
                         _commit_cache[commit_id] = get_commit_func()
                     commit = _commit_cache[commit_id]
                     author = commit.author
                     email = commit.author_email
                     user = User.get_from_cs_author(author)
                     if user:
                         user_counts[user.user_id] = user_counts.get(user.user_id, 0) + 1
                     author_counts[author] = author_counts.get(author, 0) + 1
                     email_counts[email] = email_counts.get(email, 0) + 1
 
     return {
         'commits': commits,
         'files': all_files_changes,
         'stats': stats,
         'ancestor': ancestor_id,
         # original authors of modified files
         'original_authors': {
             'users': user_counts,
             'authors': author_counts,
             'emails': email_counts,
         },
         'commit_authors': commit_authors
     }
 
 
 class PullRequestModel(BaseModel):
 
     cls = PullRequest
 
     DIFF_CONTEXT = diffs.DEFAULT_CONTEXT
 
     UPDATE_STATUS_MESSAGES = {
         UpdateFailureReason.NONE: lazy_ugettext(
             'Pull request update successful.'),
         UpdateFailureReason.UNKNOWN: lazy_ugettext(
             'Pull request update failed because of an unknown error.'),
         UpdateFailureReason.NO_CHANGE: lazy_ugettext(
             'No update needed because the source and target have not changed.'),
         UpdateFailureReason.WRONG_REF_TYPE: lazy_ugettext(
             'Pull request cannot be updated because the reference type is '
             'not supported for an update. Only Branch, Tag or Bookmark is allowed.'),
         UpdateFailureReason.MISSING_TARGET_REF: lazy_ugettext(
             'This pull request cannot be updated because the target '
             'reference is missing.'),
         UpdateFailureReason.MISSING_SOURCE_REF: lazy_ugettext(
             'This pull request cannot be updated because the source '
             'reference is missing.'),
     }
     REF_TYPES = ['bookmark', 'book', 'tag', 'branch']
     UPDATABLE_REF_TYPES = ['bookmark', 'book', 'branch']
 
     def __get_pull_request(self, pull_request):
         return self._get_instance((
             PullRequest, PullRequestVersion), pull_request)
 
     def _check_perms(self, perms, pull_request, user, api=False):
         if not api:
             return h.HasRepoPermissionAny(*perms)(
                 user=user, repo_name=pull_request.target_repo.repo_name)
         else:
             return h.HasRepoPermissionAnyApi(*perms)(
                 user=user, repo_name=pull_request.target_repo.repo_name)
 
     def check_user_read(self, pull_request, user, api=False):
         _perms = ('repository.admin', 'repository.write', 'repository.read',)
         return self._check_perms(_perms, pull_request, user, api)
 
     def check_user_merge(self, pull_request, user, api=False):
         _perms = ('repository.admin', 'repository.write', 'hg.admin',)
         return self._check_perms(_perms, pull_request, user, api)
 
     def check_user_update(self, pull_request, user, api=False):
         owner = user.user_id == pull_request.user_id
         return self.check_user_merge(pull_request, user, api) or owner
 
     def check_user_delete(self, pull_request, user):
         owner = user.user_id == pull_request.user_id
         _perms = ('repository.admin',)
         return self._check_perms(_perms, pull_request, user) or owner
 
     def check_user_change_status(self, pull_request, user, api=False):
         reviewer = user.user_id in [x.user_id for x in
                                     pull_request.reviewers]
         return self.check_user_update(pull_request, user, api) or reviewer
 
     def check_user_comment(self, pull_request, user):
         owner = user.user_id == pull_request.user_id
         return self.check_user_read(pull_request, user) or owner
 
     def get(self, pull_request):
         return self.__get_pull_request(pull_request)
 
     def _prepare_get_all_query(self, repo_name, search_q=None, source=False,
                                statuses=None, opened_by=None, order_by=None,
                                order_dir='desc', only_created=False):
         repo = None
         if repo_name:
             repo = self._get_repo(repo_name)
 
         q = PullRequest.query()
 
         if search_q:
             like_expression = u'%{}%'.format(safe_unicode(search_q))
             q = q.join(User)
             q = q.filter(or_(
                 cast(PullRequest.pull_request_id, String).ilike(like_expression),
                 User.username.ilike(like_expression),
                 PullRequest.title.ilike(like_expression),
                 PullRequest.description.ilike(like_expression),
             ))
 
         # source or target
         if repo and source:
             q = q.filter(PullRequest.source_repo == repo)
         elif repo:
             q = q.filter(PullRequest.target_repo == repo)
 
         # closed,opened
         if statuses:
             q = q.filter(PullRequest.status.in_(statuses))
 
         # opened by filter
         if opened_by:
             q = q.filter(PullRequest.user_id.in_(opened_by))
 
         # only get those that are in "created" state
         if only_created:
             q = q.filter(PullRequest.pull_request_state == PullRequest.STATE_CREATED)
 
         if order_by:
             order_map = {
                 'name_raw': PullRequest.pull_request_id,
                 'id': PullRequest.pull_request_id,
                 'title': PullRequest.title,
                 'updated_on_raw': PullRequest.updated_on,
                 'target_repo': PullRequest.target_repo_id
             }
             if order_dir == 'asc':
                 q = q.order_by(order_map[order_by].asc())
             else:
                 q = q.order_by(order_map[order_by].desc())
 
         return q
 
     def count_all(self, repo_name, search_q=None, source=False, statuses=None,
                   opened_by=None):
         """
         Count the number of pull requests for a specific repository.
 
         :param repo_name: target or source repo
         :param search_q: filter by text
         :param source: boolean flag to specify if repo_name refers to source
         :param statuses: list of pull request statuses
         :param opened_by: author user of the pull request
         :returns: int number of pull requests
         """
         q = self._prepare_get_all_query(
             repo_name, search_q=search_q, source=source, statuses=statuses,
             opened_by=opened_by)
 
         return q.count()
 
     def get_all(self, repo_name, search_q=None, source=False, statuses=None,
                 opened_by=None, offset=0, length=None, order_by=None, order_dir='desc'):
         """
         Get all pull requests for a specific repository.
 
         :param repo_name: target or source repo
         :param search_q: filter by text
         :param source: boolean flag to specify if repo_name refers to source
         :param statuses: list of pull request statuses
         :param opened_by: author user of the pull request
         :param offset: pagination offset
         :param length: length of returned list
         :param order_by: order of the returned list
         :param order_dir: 'asc' or 'desc' ordering direction
         :returns: list of pull requests
         """
         q = self._prepare_get_all_query(
             repo_name, search_q=search_q, source=source, statuses=statuses,
             opened_by=opened_by, order_by=order_by, order_dir=order_dir)
 
         if length:
             pull_requests = q.limit(length).offset(offset).all()
         else:
             pull_requests = q.all()
 
         return pull_requests
 
     def count_awaiting_review(self, repo_name, search_q=None, source=False, statuses=None,
                               opened_by=None):
         """
         Count the number of pull requests for a specific repository that are
         awaiting review.
 
         :param repo_name: target or source repo
         :param search_q: filter by text
         :param source: boolean flag to specify if repo_name refers to source
         :param statuses: list of pull request statuses
         :param opened_by: author user of the pull request
         :returns: int number of pull requests
         """
         pull_requests = self.get_awaiting_review(
             repo_name, search_q=search_q, source=source, statuses=statuses, opened_by=opened_by)
 
         return len(pull_requests)
 
     def get_awaiting_review(self, repo_name, search_q=None, source=False, statuses=None,
                             opened_by=None, offset=0, length=None,
                             order_by=None, order_dir='desc'):
         """
         Get all pull requests for a specific repository that are awaiting
         review.
 
         :param repo_name: target or source repo
         :param search_q: filter by text
         :param source: boolean flag to specify if repo_name refers to source
         :param statuses: list of pull request statuses
         :param opened_by: author user of the pull request
         :param offset: pagination offset
         :param length: length of returned list
         :param order_by: order of the returned list
         :param order_dir: 'asc' or 'desc' ordering direction
         :returns: list of pull requests
         """
         pull_requests = self.get_all(
             repo_name, search_q=search_q, source=source, statuses=statuses,
             opened_by=opened_by, order_by=order_by, order_dir=order_dir)
 
         _filtered_pull_requests = []
         for pr in pull_requests:
             status = pr.calculated_review_status()
             if status in [ChangesetStatus.STATUS_NOT_REVIEWED,
                           ChangesetStatus.STATUS_UNDER_REVIEW]:
                 _filtered_pull_requests.append(pr)
         if length:
             return _filtered_pull_requests[offset:offset+length]
         else:
             return _filtered_pull_requests
 
     def count_awaiting_my_review(self, repo_name, search_q=None, source=False, statuses=None,
                                  opened_by=None, user_id=None):
         """
         Count the number of pull requests for a specific repository that are
         awaiting review from a specific user.
 
         :param repo_name: target or source repo
         :param search_q: filter by text
         :param source: boolean flag to specify if repo_name refers to source
         :param statuses: list of pull request statuses
         :param opened_by: author user of the pull request
         :param user_id: reviewer user of the pull request
         :returns: int number of pull requests
         """
         pull_requests = self.get_awaiting_my_review(
             repo_name, search_q=search_q, source=source, statuses=statuses,
             opened_by=opened_by, user_id=user_id)
 
         return len(pull_requests)
 
     def get_awaiting_my_review(self, repo_name, search_q=None, source=False, statuses=None,
                                opened_by=None, user_id=None, offset=0,
                                length=None, order_by=None, order_dir='desc'):
         """
         Get all pull requests for a specific repository that are awaiting
         review from a specific user.
 
         :param repo_name: target or source repo
         :param search_q: filter by text
         :param source: boolean flag to specify if repo_name refers to source
         :param statuses: list of pull request statuses
         :param opened_by: author user of the pull request
         :param user_id: reviewer user of the pull request
         :param offset: pagination offset
         :param length: length of returned list
         :param order_by: order of the returned list
         :param order_dir: 'asc' or 'desc' ordering direction
         :returns: list of pull requests
         """
         pull_requests = self.get_all(
             repo_name, search_q=search_q, source=source, statuses=statuses,
             opened_by=opened_by, order_by=order_by, order_dir=order_dir)
 
         _my = PullRequestModel().get_not_reviewed(user_id)
         my_participation = []
         for pr in pull_requests:
             if pr in _my:
                 my_participation.append(pr)
         _filtered_pull_requests = my_participation
         if length:
             return _filtered_pull_requests[offset:offset+length]
         else:
             return _filtered_pull_requests
 
     def get_not_reviewed(self, user_id):
         return [
             x.pull_request for x in PullRequestReviewers.query().filter(
                 PullRequestReviewers.user_id == user_id).all()
         ]
 
     def _prepare_participating_query(self, user_id=None, statuses=None, query='',
                                      order_by=None, order_dir='desc'):
         q = PullRequest.query()
         if user_id:
             reviewers_subquery = Session().query(
                 PullRequestReviewers.pull_request_id).filter(
                 PullRequestReviewers.user_id == user_id).subquery()
             user_filter = or_(
                 PullRequest.user_id == user_id,
                 PullRequest.pull_request_id.in_(reviewers_subquery)
             )
             q = PullRequest.query().filter(user_filter)
 
         # closed,opened
         if statuses:
             q = q.filter(PullRequest.status.in_(statuses))
 
         if query:
             like_expression = u'%{}%'.format(safe_unicode(query))
             q = q.join(User)
             q = q.filter(or_(
                 cast(PullRequest.pull_request_id, String).ilike(like_expression),
                 User.username.ilike(like_expression),
                 PullRequest.title.ilike(like_expression),
                 PullRequest.description.ilike(like_expression),
             ))
         if order_by:
             order_map = {
                 'name_raw': PullRequest.pull_request_id,
                 'title': PullRequest.title,
                 'updated_on_raw': PullRequest.updated_on,
                 'target_repo': PullRequest.target_repo_id
             }
             if order_dir == 'asc':
                 q = q.order_by(order_map[order_by].asc())
             else:
                 q = q.order_by(order_map[order_by].desc())
 
         return q
 
     def count_im_participating_in(self, user_id=None, statuses=None, query=''):
         q = self._prepare_participating_query(user_id, statuses=statuses, query=query)
         return q.count()
 
     def get_im_participating_in(
             self, user_id=None, statuses=None, query='', offset=0,
             length=None, order_by=None, order_dir='desc'):
         """
         Get all Pull requests that i'm participating in, or i have opened
         """
 
         q = self._prepare_participating_query(
             user_id, statuses=statuses, query=query, order_by=order_by,
             order_dir=order_dir)
 
         if length:
             pull_requests = q.limit(length).offset(offset).all()
         else:
             pull_requests = q.all()
 
         return pull_requests
 
     def get_versions(self, pull_request):
         """
         returns version of pull request sorted by ID descending
         """
         return PullRequestVersion.query()\
             .filter(PullRequestVersion.pull_request == pull_request)\
             .order_by(PullRequestVersion.pull_request_version_id.asc())\
             .all()
 
     def get_pr_version(self, pull_request_id, version=None):
         at_version = None
 
         if version and version == 'latest':
             pull_request_ver = PullRequest.get(pull_request_id)
             pull_request_obj = pull_request_ver
             _org_pull_request_obj = pull_request_obj
             at_version = 'latest'
         elif version:
             pull_request_ver = PullRequestVersion.get_or_404(version)
             pull_request_obj = pull_request_ver
             _org_pull_request_obj = pull_request_ver.pull_request
             at_version = pull_request_ver.pull_request_version_id
         else:
             _org_pull_request_obj = pull_request_obj = PullRequest.get_or_404(
                 pull_request_id)
 
         pull_request_display_obj = PullRequest.get_pr_display_object(
             pull_request_obj, _org_pull_request_obj)
 
         return _org_pull_request_obj, pull_request_obj, \
                pull_request_display_obj, at_version
 
     def create(self, created_by, source_repo, source_ref, target_repo,
-               target_ref, revisions, reviewers, title, description=None,
+               target_ref, revisions, reviewers, observers, title, description=None,
                common_ancestor_id=None,
                description_renderer=None,
                reviewer_data=None, translator=None, auth_user=None):
         translator = translator or get_current_request().translate
 
         created_by_user = self._get_user(created_by)
         auth_user = auth_user or created_by_user.AuthUser()
         source_repo = self._get_repo(source_repo)
         target_repo = self._get_repo(target_repo)
 
         pull_request = PullRequest()
         pull_request.source_repo = source_repo
         pull_request.source_ref = source_ref
         pull_request.target_repo = target_repo
         pull_request.target_ref = target_ref
         pull_request.revisions = revisions
         pull_request.title = title
         pull_request.description = description
         pull_request.description_renderer = description_renderer
         pull_request.author = created_by_user
         pull_request.reviewer_data = reviewer_data
         pull_request.pull_request_state = pull_request.STATE_CREATING
         pull_request.common_ancestor_id = common_ancestor_id
 
         Session().add(pull_request)
         Session().flush()
 
         reviewer_ids = set()
         # members / reviewers
         for reviewer_object in reviewers:
-            user_id, reasons, mandatory, rules = reviewer_object
+            user_id, reasons, mandatory, role, rules = reviewer_object
             user = self._get_user(user_id)
 
             # skip duplicates
             if user.user_id in reviewer_ids:
                 continue
 
             reviewer_ids.add(user.user_id)
 
             reviewer = PullRequestReviewers()
             reviewer.user = user
             reviewer.pull_request = pull_request
             reviewer.reasons = reasons
             reviewer.mandatory = mandatory
+            reviewer.role = role
 
             # NOTE(marcink): pick only first rule for now
             rule_id = list(rules)[0] if rules else None
             rule = RepoReviewRule.get(rule_id) if rule_id else None
             if rule:
                 review_group = rule.user_group_vote_rule(user_id)
                 # we check if this particular reviewer is member of a voting group
                 if review_group:
                     # NOTE(marcink):
                     # can be that user is member of more but we pick the first same,
                     # same as default reviewers algo
                     review_group = review_group[0]
 
                     rule_data = {
                         'rule_name':
                             rule.review_rule_name,
                         'rule_user_group_entry_id':
                             review_group.repo_review_rule_users_group_id,
                         'rule_user_group_name':
                             review_group.users_group.users_group_name,
                         'rule_user_group_members':
                             [x.user.username for x in review_group.users_group.members],
                         'rule_user_group_members_id':
                             [x.user.user_id for x in review_group.users_group.members],
                     }
                     # e.g {'vote_rule': -1, 'mandatory': True}
                     rule_data.update(review_group.rule_data())
 
                     reviewer.rule_data = rule_data
 
             Session().add(reviewer)
             Session().flush()
 
+        for observer_object in observers:
+            user_id, reasons, mandatory, role, rules = observer_object
+            user = self._get_user(user_id)
+
+            # skip duplicates from reviewers
+            if user.user_id in reviewer_ids:
+                continue
+
+            #reviewer_ids.add(user.user_id)
+
+            observer = PullRequestReviewers()
+            observer.user = user
+            observer.pull_request = pull_request
+            observer.reasons = reasons
+            observer.mandatory = mandatory
+            observer.role = role
+
+            # NOTE(marcink): pick only first rule for now
+            rule_id = list(rules)[0] if rules else None
+            rule = RepoReviewRule.get(rule_id) if rule_id else None
+            if rule:
+                # TODO(marcink): do we need this for observers ??
+                pass
+
+            Session().add(observer)
+            Session().flush()
+
         # Set approval status to "Under Review" for all commits which are
         # part of this pull request.
         ChangesetStatusModel().set_status(
             repo=target_repo,
             status=ChangesetStatus.STATUS_UNDER_REVIEW,
             user=created_by_user,
             pull_request=pull_request
         )
         # we commit early at this point. This has to do with a fact
         # that before queries do some row-locking. And because of that
         # we need to commit and finish transaction before below validate call
         # that for large repos could be long resulting in long row locks
         Session().commit()
 
         # prepare workspace, and run initial merge simulation. Set state during that
         # operation
         pull_request = PullRequest.get(pull_request.pull_request_id)
 
         # set as merging, for merge simulation, and if finished to created so we mark
         # simulation is working fine
         with pull_request.set_state(PullRequest.STATE_MERGING,
                                     final_state=PullRequest.STATE_CREATED) as state_obj:
             MergeCheck.validate(
                 pull_request, auth_user=auth_user, translator=translator)
 
         self.notify_reviewers(pull_request, reviewer_ids)
         self.trigger_pull_request_hook(pull_request, created_by_user, 'create')
 
         creation_data = pull_request.get_api_data(with_merge_state=False)
         self._log_audit_action(
             'repo.pull_request.create', {'data': creation_data},
             auth_user, pull_request)
 
         return pull_request
 
     def trigger_pull_request_hook(self, pull_request, user, action, data=None):
         pull_request = self.__get_pull_request(pull_request)
         target_scm = pull_request.target_repo.scm_instance()
         if action == 'create':
             trigger_hook = hooks_utils.trigger_create_pull_request_hook
         elif action == 'merge':
             trigger_hook = hooks_utils.trigger_merge_pull_request_hook
         elif action == 'close':
             trigger_hook = hooks_utils.trigger_close_pull_request_hook
         elif action == 'review_status_change':
             trigger_hook = hooks_utils.trigger_review_pull_request_hook
         elif action == 'update':
             trigger_hook = hooks_utils.trigger_update_pull_request_hook
         elif action == 'comment':
             trigger_hook = hooks_utils.trigger_comment_pull_request_hook
         elif action == 'comment_edit':
             trigger_hook = hooks_utils.trigger_comment_pull_request_edit_hook
         else:
             return
 
         log.debug('Handling pull_request %s trigger_pull_request_hook with action %s and hook: %s',
                   pull_request, action, trigger_hook)
         trigger_hook(
             username=user.username,
             repo_name=pull_request.target_repo.repo_name,
             repo_type=target_scm.alias,
             pull_request=pull_request,
             data=data)
 
     def _get_commit_ids(self, pull_request):
         """
         Return the commit ids of the merged pull request.
 
         This method is not dealing correctly yet with the lack of autoupdates
         nor with the implicit target updates.
         For example: if a commit in the source repo is already in the target it
         will be reported anyways.
         """
         merge_rev = pull_request.merge_rev
         if merge_rev is None:
             raise ValueError('This pull request was not merged yet')
 
         commit_ids = list(pull_request.revisions)
         if merge_rev not in commit_ids:
             commit_ids.append(merge_rev)
 
         return commit_ids
 
     def merge_repo(self, pull_request, user, extras):
         log.debug("Merging pull request %s", pull_request.pull_request_id)
         extras['user_agent'] = 'internal-merge'
         merge_state = self._merge_pull_request(pull_request, user, extras)
         if merge_state.executed:
             log.debug("Merge was successful, updating the pull request comments.")
             self._comment_and_close_pr(pull_request, user, merge_state)
 
             self._log_audit_action(
                 'repo.pull_request.merge',
                 {'merge_state': merge_state.__dict__},
                 user, pull_request)
 
         else:
             log.warn("Merge failed, not updating the pull request.")
         return merge_state
 
     def _merge_pull_request(self, pull_request, user, extras, merge_msg=None):
         target_vcs = pull_request.target_repo.scm_instance()
         source_vcs = pull_request.source_repo.scm_instance()
 
         message = safe_unicode(merge_msg or vcs_settings.MERGE_MESSAGE_TMPL).format(
             pr_id=pull_request.pull_request_id,
             pr_title=pull_request.title,
             source_repo=source_vcs.name,
             source_ref_name=pull_request.source_ref_parts.name,
             target_repo=target_vcs.name,
             target_ref_name=pull_request.target_ref_parts.name,
         )
 
         workspace_id = self._workspace_id(pull_request)
         repo_id = pull_request.target_repo.repo_id
         use_rebase = self._use_rebase_for_merging(pull_request)
         close_branch = self._close_branch_before_merging(pull_request)
         user_name = self._user_name_for_merging(pull_request, user)
 
         target_ref = self._refresh_reference(
             pull_request.target_ref_parts, target_vcs)
 
         callback_daemon, extras = prepare_callback_daemon(
             extras, protocol=vcs_settings.HOOKS_PROTOCOL,
             host=vcs_settings.HOOKS_HOST,
             use_direct_calls=vcs_settings.HOOKS_DIRECT_CALLS)
 
         with callback_daemon:
             # TODO: johbo: Implement a clean way to run a config_override
             # for a single call.
             target_vcs.config.set(
                 'rhodecode', 'RC_SCM_DATA', json.dumps(extras))
 
             merge_state = target_vcs.merge(
                 repo_id, workspace_id, target_ref, source_vcs,
                 pull_request.source_ref_parts,
                 user_name=user_name, user_email=user.email,
                 message=message, use_rebase=use_rebase,
                 close_branch=close_branch)
         return merge_state
 
     def _comment_and_close_pr(self, pull_request, user, merge_state, close_msg=None):
         pull_request.merge_rev = merge_state.merge_ref.commit_id
         pull_request.updated_on = datetime.datetime.now()
         close_msg = close_msg or 'Pull request merged and closed'
 
         CommentsModel().create(
             text=safe_unicode(close_msg),
             repo=pull_request.target_repo.repo_id,
             user=user.user_id,
             pull_request=pull_request.pull_request_id,
             f_path=None,
             line_no=None,
             closing_pr=True
         )
 
         Session().add(pull_request)
         Session().flush()
         # TODO: paris: replace invalidation with less radical solution
         ScmModel().mark_for_invalidation(
             pull_request.target_repo.repo_name)
         self.trigger_pull_request_hook(pull_request, user, 'merge')
 
     def has_valid_update_type(self, pull_request):
         source_ref_type = pull_request.source_ref_parts.type
         return source_ref_type in self.REF_TYPES
 
     def get_flow_commits(self, pull_request):
 
         # source repo
         source_ref_name = pull_request.source_ref_parts.name
         source_ref_type = pull_request.source_ref_parts.type
         source_ref_id = pull_request.source_ref_parts.commit_id
         source_repo = pull_request.source_repo.scm_instance()
 
         try:
             if source_ref_type in self.REF_TYPES:
                 source_commit = source_repo.get_commit(source_ref_name)
             else:
                 source_commit = source_repo.get_commit(source_ref_id)
         except CommitDoesNotExistError:
             raise SourceRefMissing()
 
         # target repo
         target_ref_name = pull_request.target_ref_parts.name
         target_ref_type = pull_request.target_ref_parts.type
         target_ref_id = pull_request.target_ref_parts.commit_id
         target_repo = pull_request.target_repo.scm_instance()
 
         try:
             if target_ref_type in self.REF_TYPES:
                 target_commit = target_repo.get_commit(target_ref_name)
             else:
                 target_commit = target_repo.get_commit(target_ref_id)
         except CommitDoesNotExistError:
             raise TargetRefMissing()
 
         return source_commit, target_commit
 
     def update_commits(self, pull_request, updating_user):
         """
         Get the updated list of commits for the pull request
         and return the new pull request version and the list
         of commits processed by this update action
 
         updating_user is the user_object who triggered the update
         """
         pull_request = self.__get_pull_request(pull_request)
         source_ref_type = pull_request.source_ref_parts.type
         source_ref_name = pull_request.source_ref_parts.name
         source_ref_id = pull_request.source_ref_parts.commit_id
 
         target_ref_type = pull_request.target_ref_parts.type
         target_ref_name = pull_request.target_ref_parts.name
         target_ref_id = pull_request.target_ref_parts.commit_id
 
         if not self.has_valid_update_type(pull_request):
             log.debug("Skipping update of pull request %s due to ref type: %s",
                       pull_request, source_ref_type)
             return UpdateResponse(
                 executed=False,
                 reason=UpdateFailureReason.WRONG_REF_TYPE,
                 old=pull_request, new=None, common_ancestor_id=None, commit_changes=None,
                 source_changed=False, target_changed=False)
 
         try:
             source_commit, target_commit = self.get_flow_commits(pull_request)
         except SourceRefMissing:
             return UpdateResponse(
                 executed=False,
                 reason=UpdateFailureReason.MISSING_SOURCE_REF,
                 old=pull_request, new=None, common_ancestor_id=None, commit_changes=None,
                 source_changed=False, target_changed=False)
         except TargetRefMissing:
             return UpdateResponse(
                 executed=False,
                 reason=UpdateFailureReason.MISSING_TARGET_REF,
                 old=pull_request, new=None, common_ancestor_id=None, commit_changes=None,
                 source_changed=False, target_changed=False)
 
         source_changed = source_ref_id != source_commit.raw_id
         target_changed = target_ref_id != target_commit.raw_id
 
         if not (source_changed or target_changed):
             log.debug("Nothing changed in pull request %s", pull_request)
             return UpdateResponse(
                 executed=False,
                 reason=UpdateFailureReason.NO_CHANGE,
                 old=pull_request, new=None, common_ancestor_id=None, commit_changes=None,
                 source_changed=target_changed, target_changed=source_changed)
 
         change_in_found = 'target repo' if target_changed else 'source repo'
         log.debug('Updating pull request because of change in %s detected',
                   change_in_found)
 
         # Finally there is a need for an update, in case of source change
         # we create a new version, else just an update
         if source_changed:
             pull_request_version = self._create_version_from_snapshot(pull_request)
             self._link_comments_to_version(pull_request_version)
         else:
             try:
                 ver = pull_request.versions[-1]
             except IndexError:
                 ver = None
 
             pull_request.pull_request_version_id = \
                 ver.pull_request_version_id if ver else None
             pull_request_version = pull_request
 
         source_repo = pull_request.source_repo.scm_instance()
         target_repo = pull_request.target_repo.scm_instance()
 
         # re-compute commit ids
         old_commit_ids = pull_request.revisions
         pre_load = ["author", "date", "message", "branch"]
         commit_ranges = target_repo.compare(
             target_commit.raw_id, source_commit.raw_id, source_repo, merge=True,
             pre_load=pre_load)
 
         target_ref = target_commit.raw_id
         source_ref = source_commit.raw_id
         ancestor_commit_id = target_repo.get_common_ancestor(
             target_ref, source_ref, source_repo)
 
         if not ancestor_commit_id:
             raise ValueError(
                 'cannot calculate diff info without a common ancestor. '
                 'Make sure both repositories are related, and have a common forking commit.')
 
         pull_request.common_ancestor_id = ancestor_commit_id
 
         pull_request.source_ref = '%s:%s:%s' % (
             source_ref_type, source_ref_name, source_commit.raw_id)
         pull_request.target_ref = '%s:%s:%s' % (
             target_ref_type, target_ref_name, ancestor_commit_id)
 
         pull_request.revisions = [
             commit.raw_id for commit in reversed(commit_ranges)]
         pull_request.updated_on = datetime.datetime.now()
         Session().add(pull_request)
         new_commit_ids = pull_request.revisions
 
         old_diff_data, new_diff_data = self._generate_update_diffs(
             pull_request, pull_request_version)
 
         # calculate commit and file changes
         commit_changes = self._calculate_commit_id_changes(
             old_commit_ids, new_commit_ids)
         file_changes = self._calculate_file_changes(
             old_diff_data, new_diff_data)
 
         # set comments as outdated if DIFFS changed
         CommentsModel().outdate_comments(
             pull_request, old_diff_data=old_diff_data,
             new_diff_data=new_diff_data)
 
         valid_commit_changes = (commit_changes.added or commit_changes.removed)
         file_node_changes = (
             file_changes.added or file_changes.modified or file_changes.removed)
         pr_has_changes = valid_commit_changes or file_node_changes
 
         # Add an automatic comment to the pull request, in case
         # anything has changed
         if pr_has_changes:
             update_comment = CommentsModel().create(
                 text=self._render_update_message(ancestor_commit_id, commit_changes, file_changes),
                 repo=pull_request.target_repo,
                 user=pull_request.author,
                 pull_request=pull_request,
                 send_email=False, renderer=DEFAULT_COMMENTS_RENDERER)
 
             # Update status to "Under Review" for added commits
             for commit_id in commit_changes.added:
                 ChangesetStatusModel().set_status(
                     repo=pull_request.source_repo,
                     status=ChangesetStatus.STATUS_UNDER_REVIEW,
                     comment=update_comment,
                     user=pull_request.author,
                     pull_request=pull_request,
                     revision=commit_id)
 
             # send update email to users
             try:
                 self.notify_users(pull_request=pull_request, updating_user=updating_user,
                                   ancestor_commit_id=ancestor_commit_id,
                                   commit_changes=commit_changes,
                                   file_changes=file_changes)
             except Exception:
                 log.exception('Failed to send email notification to users')
 
         log.debug(
             'Updated pull request %s, added_ids: %s, common_ids: %s, '
             'removed_ids: %s', pull_request.pull_request_id,
             commit_changes.added, commit_changes.common, commit_changes.removed)
         log.debug(
             'Updated pull request with the following file changes: %s',
             file_changes)
 
         log.info(
             "Updated pull request %s from commit %s to commit %s, "
             "stored new version %s of this pull request.",
             pull_request.pull_request_id, source_ref_id,
             pull_request.source_ref_parts.commit_id,
             pull_request_version.pull_request_version_id)
         Session().commit()
         self.trigger_pull_request_hook(pull_request, pull_request.author, 'update')
 
         return UpdateResponse(
             executed=True, reason=UpdateFailureReason.NONE,
             old=pull_request, new=pull_request_version,
             common_ancestor_id=ancestor_commit_id, commit_changes=commit_changes,
             source_changed=source_changed, target_changed=target_changed)
 
     def _create_version_from_snapshot(self, pull_request):
         version = PullRequestVersion()
         version.title = pull_request.title
         version.description = pull_request.description
         version.status = pull_request.status
         version.pull_request_state = pull_request.pull_request_state
         version.created_on = datetime.datetime.now()
         version.updated_on = pull_request.updated_on
         version.user_id = pull_request.user_id
         version.source_repo = pull_request.source_repo
         version.source_ref = pull_request.source_ref
         version.target_repo = pull_request.target_repo
         version.target_ref = pull_request.target_ref
 
         version._last_merge_source_rev = pull_request._last_merge_source_rev
         version._last_merge_target_rev = pull_request._last_merge_target_rev
         version.last_merge_status = pull_request.last_merge_status
         version.last_merge_metadata = pull_request.last_merge_metadata
         version.shadow_merge_ref = pull_request.shadow_merge_ref
         version.merge_rev = pull_request.merge_rev
         version.reviewer_data = pull_request.reviewer_data
 
         version.revisions = pull_request.revisions
         version.common_ancestor_id = pull_request.common_ancestor_id
         version.pull_request = pull_request
         Session().add(version)
         Session().flush()
 
         return version
 
     def _generate_update_diffs(self, pull_request, pull_request_version):
 
         diff_context = (
             self.DIFF_CONTEXT +
             CommentsModel.needed_extra_diff_context())
         hide_whitespace_changes = False
         source_repo = pull_request_version.source_repo
         source_ref_id = pull_request_version.source_ref_parts.commit_id
         target_ref_id = pull_request_version.target_ref_parts.commit_id
         old_diff = self._get_diff_from_pr_or_version(
             source_repo, source_ref_id, target_ref_id,
             hide_whitespace_changes=hide_whitespace_changes, diff_context=diff_context)
 
         source_repo = pull_request.source_repo
         source_ref_id = pull_request.source_ref_parts.commit_id
         target_ref_id = pull_request.target_ref_parts.commit_id
 
         new_diff = self._get_diff_from_pr_or_version(
             source_repo, source_ref_id, target_ref_id,
             hide_whitespace_changes=hide_whitespace_changes, diff_context=diff_context)
 
         old_diff_data = diffs.DiffProcessor(old_diff)
         old_diff_data.prepare()
         new_diff_data = diffs.DiffProcessor(new_diff)
         new_diff_data.prepare()
 
         return old_diff_data, new_diff_data
 
     def _link_comments_to_version(self, pull_request_version):
         """
         Link all unlinked comments of this pull request to the given version.
 
         :param pull_request_version: The `PullRequestVersion` to which
             the comments shall be linked.
 
         """
         pull_request = pull_request_version.pull_request
         comments = ChangesetComment.query()\
             .filter(
                 # TODO: johbo: Should we query for the repo at all here?
                 # Pending decision on how comments of PRs are to be related
                 # to either the source repo, the target repo or no repo at all.
                 ChangesetComment.repo_id == pull_request.target_repo.repo_id,
                 ChangesetComment.pull_request == pull_request,
                 ChangesetComment.pull_request_version == None)\
             .order_by(ChangesetComment.comment_id.asc())
 
         # TODO: johbo: Find out why this breaks if it is done in a bulk
         # operation.
         for comment in comments:
             comment.pull_request_version_id = (
                 pull_request_version.pull_request_version_id)
             Session().add(comment)
 
     def _calculate_commit_id_changes(self, old_ids, new_ids):
         added = [x for x in new_ids if x not in old_ids]
         common = [x for x in new_ids if x in old_ids]
         removed = [x for x in old_ids if x not in new_ids]
         total = new_ids
         return ChangeTuple(added, common, removed, total)
 
     def _calculate_file_changes(self, old_diff_data, new_diff_data):
 
         old_files = OrderedDict()
         for diff_data in old_diff_data.parsed_diff:
             old_files[diff_data['filename']] = md5_safe(diff_data['raw_diff'])
 
         added_files = []
         modified_files = []
         removed_files = []
         for diff_data in new_diff_data.parsed_diff:
             new_filename = diff_data['filename']
             new_hash = md5_safe(diff_data['raw_diff'])
 
             old_hash = old_files.get(new_filename)
             if not old_hash:
                 # file is not present in old diff, we have to figure out from parsed diff
                 # operation ADD/REMOVE
                 operations_dict = diff_data['stats']['ops']
                 if diffs.DEL_FILENODE in operations_dict:
                     removed_files.append(new_filename)
                 else:
                     added_files.append(new_filename)
             else:
                 if new_hash != old_hash:
                     modified_files.append(new_filename)
                 # now remove a file from old, since we have seen it already
                 del old_files[new_filename]
 
         # removed files is when there are present in old, but not in NEW,
         # since we remove old files that are present in new diff, left-overs
         # if any should be the removed files
         removed_files.extend(old_files.keys())
 
         return FileChangeTuple(added_files, modified_files, removed_files)
 
     def _render_update_message(self, ancestor_commit_id, changes, file_changes):
         """
         render the message using DEFAULT_COMMENTS_RENDERER (RST renderer),
         so it's always looking the same disregarding on which default
         renderer system is using.
 
         :param ancestor_commit_id: ancestor raw_id
         :param changes: changes named tuple
         :param file_changes: file changes named tuple
 
         """
         new_status = ChangesetStatus.get_status_lbl(
             ChangesetStatus.STATUS_UNDER_REVIEW)
 
         changed_files = (
             file_changes.added + file_changes.modified + file_changes.removed)
 
         params = {
             'under_review_label': new_status,
             'added_commits': changes.added,
             'removed_commits': changes.removed,
             'changed_files': changed_files,
             'added_files': file_changes.added,
             'modified_files': file_changes.modified,
             'removed_files': file_changes.removed,
             'ancestor_commit_id': ancestor_commit_id
         }
         renderer = RstTemplateRenderer()
         return renderer.render('pull_request_update.mako', **params)
 
     def edit(self, pull_request, title, description, description_renderer, user):
         pull_request = self.__get_pull_request(pull_request)
         old_data = pull_request.get_api_data(with_merge_state=False)
         if pull_request.is_closed():
             raise ValueError('This pull request is closed')
         if title:
             pull_request.title = title
         pull_request.description = description
         pull_request.updated_on = datetime.datetime.now()
         pull_request.description_renderer = description_renderer
         Session().add(pull_request)
         self._log_audit_action(
             'repo.pull_request.edit', {'old_data': old_data},
             user, pull_request)
 
     def update_reviewers(self, pull_request, reviewer_data, user):
         """
         Update the reviewers in the pull request
 
         :param pull_request: the pr to update
         :param reviewer_data: list of tuples
-            [(user, ['reason1', 'reason2'], mandatory_flag, [rules])]
+            [(user, ['reason1', 'reason2'], mandatory_flag, role, [rules])]
+        :param user: current use who triggers this action
         """
+
         pull_request = self.__get_pull_request(pull_request)
         if pull_request.is_closed():
             raise ValueError('This pull request is closed')
 
         reviewers = {}
-        for user_id, reasons, mandatory, rules in reviewer_data:
+        for user_id, reasons, mandatory, role, rules in reviewer_data:
             if isinstance(user_id, (int, compat.string_types)):
                 user_id = self._get_user(user_id).user_id
             reviewers[user_id] = {
-                'reasons': reasons, 'mandatory': mandatory}
+                'reasons': reasons, 'mandatory': mandatory, 'role': role}
 
         reviewers_ids = set(reviewers.keys())
-        current_reviewers = PullRequestReviewers.query()\
-            .filter(PullRequestReviewers.pull_request ==
-                    pull_request).all()
+        current_reviewers = PullRequestReviewers.get_pull_request_reviewers(
+            pull_request.pull_request_id, role=PullRequestReviewers.ROLE_REVIEWER)
+
         current_reviewers_ids = set([x.user.user_id for x in current_reviewers])
 
         ids_to_add = reviewers_ids.difference(current_reviewers_ids)
         ids_to_remove = current_reviewers_ids.difference(reviewers_ids)
 
         log.debug("Adding %s reviewers", ids_to_add)
         log.debug("Removing %s reviewers", ids_to_remove)
         changed = False
         added_audit_reviewers = []
         removed_audit_reviewers = []
 
         for uid in ids_to_add:
             changed = True
             _usr = self._get_user(uid)
             reviewer = PullRequestReviewers()
             reviewer.user = _usr
             reviewer.pull_request = pull_request
             reviewer.reasons = reviewers[uid]['reasons']
             # NOTE(marcink): mandatory shouldn't be changed now
             # reviewer.mandatory = reviewers[uid]['reasons']
+            # NOTE(marcink): role should be hardcoded, so we won't edit it.
+            reviewer.role = PullRequestReviewers.ROLE_REVIEWER
             Session().add(reviewer)
             added_audit_reviewers.append(reviewer.get_dict())
 
         for uid in ids_to_remove:
             changed = True
-            # NOTE(marcink): we fetch "ALL" reviewers using .all(). This is an edge case
-            # that prevents and fixes cases that we added the same reviewer twice.
+            # NOTE(marcink): we fetch "ALL" reviewers objects using .all().
+            # This is an edge case that handles previous state of having the same reviewer twice.
             # this CAN happen due to the lack of DB checks
             reviewers = PullRequestReviewers.query()\
                 .filter(PullRequestReviewers.user_id == uid,
+                        PullRequestReviewers.role == PullRequestReviewers.ROLE_REVIEWER,
                         PullRequestReviewers.pull_request == pull_request)\
                 .all()
 
             for obj in reviewers:
                 added_audit_reviewers.append(obj.get_dict())
                 Session().delete(obj)
 
         if changed:
             Session().expire_all()
             pull_request.updated_on = datetime.datetime.now()
             Session().add(pull_request)
 
         # finally store audit logs
         for user_data in added_audit_reviewers:
             self._log_audit_action(
                 'repo.pull_request.reviewer.add', {'data': user_data},
                 user, pull_request)
         for user_data in removed_audit_reviewers:
             self._log_audit_action(
                 'repo.pull_request.reviewer.delete', {'old_data': user_data},
                 user, pull_request)
 
-        self.notify_reviewers(pull_request, ids_to_add)
+        self.notify_reviewers(pull_request, ids_to_add, user.get_instance())
+        return ids_to_add, ids_to_remove
+
+    def update_observers(self, pull_request, observer_data, user):
+        """
+        Update the observers in the pull request
+
+        :param pull_request: the pr to update
+        :param observer_data: list of tuples
+            [(user, ['reason1', 'reason2'], mandatory_flag, role, [rules])]
+        :param user: current use who triggers this action
+        """
+        pull_request = self.__get_pull_request(pull_request)
+        if pull_request.is_closed():
+            raise ValueError('This pull request is closed')
+
+        observers = {}
+        for user_id, reasons, mandatory, role, rules in observer_data:
+            if isinstance(user_id, (int, compat.string_types)):
+                user_id = self._get_user(user_id).user_id
+            observers[user_id] = {
+                'reasons': reasons, 'observers': mandatory, 'role': role}
+
+        observers_ids = set(observers.keys())
+        current_observers = PullRequestReviewers.get_pull_request_reviewers(
+            pull_request.pull_request_id, role=PullRequestReviewers.ROLE_OBSERVER)
+
+        current_observers_ids = set([x.user.user_id for x in current_observers])
+
+        ids_to_add = observers_ids.difference(current_observers_ids)
+        ids_to_remove = current_observers_ids.difference(observers_ids)
+
+        log.debug("Adding %s observer", ids_to_add)
+        log.debug("Removing %s observer", ids_to_remove)
+        changed = False
+        added_audit_observers = []
+        removed_audit_observers = []
+
+        for uid in ids_to_add:
+            changed = True
+            _usr = self._get_user(uid)
+            observer = PullRequestReviewers()
+            observer.user = _usr
+            observer.pull_request = pull_request
+            observer.reasons = observers[uid]['reasons']
+            # NOTE(marcink): mandatory shouldn't be changed now
+            # observer.mandatory = observer[uid]['reasons']
+
+            # NOTE(marcink): role should be hardcoded, so we won't edit it.
+            observer.role = PullRequestReviewers.ROLE_OBSERVER
+            Session().add(observer)
+            added_audit_observers.append(observer.get_dict())
+
+        for uid in ids_to_remove:
+            changed = True
+            # NOTE(marcink): we fetch "ALL" reviewers objects using .all().
+            # This is an edge case that handles previous state of having the same reviewer twice.
+            # this CAN happen due to the lack of DB checks
+            observers = PullRequestReviewers.query()\
+                .filter(PullRequestReviewers.user_id == uid,
+                        PullRequestReviewers.role == PullRequestReviewers.ROLE_OBSERVER,
+                        PullRequestReviewers.pull_request == pull_request)\
+                .all()
+
+            for obj in observers:
+                added_audit_observers.append(obj.get_dict())
+                Session().delete(obj)
+
+        if changed:
+            Session().expire_all()
+            pull_request.updated_on = datetime.datetime.now()
+            Session().add(pull_request)
+
+        # finally store audit logs
+        for user_data in added_audit_observers:
+            self._log_audit_action(
+                'repo.pull_request.observer.add', {'data': user_data},
+                user, pull_request)
+        for user_data in removed_audit_observers:
+            self._log_audit_action(
+                'repo.pull_request.observer.delete', {'old_data': user_data},
+                user, pull_request)
+
+        self.notify_observers(pull_request, ids_to_add, user.get_instance())
         return ids_to_add, ids_to_remove
 
     def get_url(self, pull_request, request=None, permalink=False):
         if not request:
             request = get_current_request()
 
         if permalink:
             return request.route_url(
                 'pull_requests_global',
                 pull_request_id=pull_request.pull_request_id,)
         else:
             return request.route_url('pullrequest_show',
                 repo_name=safe_str(pull_request.target_repo.repo_name),
                 pull_request_id=pull_request.pull_request_id,)
 
     def get_shadow_clone_url(self, pull_request, request=None):
         """
         Returns qualified url pointing to the shadow repository. If this pull
         request is closed there is no shadow repository and ``None`` will be
         returned.
         """
         if pull_request.is_closed():
             return None
         else:
             pr_url = urllib.unquote(self.get_url(pull_request, request=request))
             return safe_unicode('{pr_url}/repository'.format(pr_url=pr_url))
 
-    def notify_reviewers(self, pull_request, reviewers_ids):
-        # notification to reviewers
-        if not reviewers_ids:
+    def _notify_reviewers(self, pull_request, user_ids, role, user):
+        # notification to reviewers/observers
+        if not user_ids:
             return
 
-        log.debug('Notify following reviewers about pull-request %s', reviewers_ids)
+        log.debug('Notify following %s users about pull-request %s', role, user_ids)
 
         pull_request_obj = pull_request
         # get the current participants of this pull request
-        recipients = reviewers_ids
+        recipients = user_ids
         notification_type = EmailNotificationModel.TYPE_PULL_REQUEST
 
         pr_source_repo = pull_request_obj.source_repo
         pr_target_repo = pull_request_obj.target_repo
 
         pr_url = h.route_url('pullrequest_show',
                              repo_name=pr_target_repo.repo_name,
                              pull_request_id=pull_request_obj.pull_request_id,)
 
         # set some variables for email notification
         pr_target_repo_url = h.route_url(
             'repo_summary', repo_name=pr_target_repo.repo_name)
 
         pr_source_repo_url = h.route_url(
             'repo_summary', repo_name=pr_source_repo.repo_name)
 
         # pull request specifics
         pull_request_commits = [
             (x.raw_id, x.message)
             for x in map(pr_source_repo.get_commit, pull_request.revisions)]
 
+        current_rhodecode_user = user
         kwargs = {
-            'user': pull_request.author,
+            'user': current_rhodecode_user,
+            'pull_request_author': pull_request.author,
             'pull_request': pull_request_obj,
             'pull_request_commits': pull_request_commits,
 
             'pull_request_target_repo': pr_target_repo,
             'pull_request_target_repo_url': pr_target_repo_url,
 
             'pull_request_source_repo': pr_source_repo,
             'pull_request_source_repo_url': pr_source_repo_url,
 
             'pull_request_url': pr_url,
             'thread_ids': [pr_url],
+            'user_role': role
         }
 
         # pre-generate the subject for notification itself
         (subject, _e, body_plaintext) = EmailNotificationModel().render_email(
             notification_type, **kwargs)
 
         # create notification objects, and emails
         NotificationModel().create(
-            created_by=pull_request.author,
+            created_by=current_rhodecode_user,
             notification_subject=subject,
             notification_body=body_plaintext,
             notification_type=notification_type,
             recipients=recipients,
             email_kwargs=kwargs,
         )
 
+    def notify_reviewers(self, pull_request, reviewers_ids, user):
+        return self._notify_reviewers(pull_request, reviewers_ids,
+                                      PullRequestReviewers.ROLE_REVIEWER, user)
+
+    def notify_observers(self, pull_request, observers_ids, user):
+        return self._notify_reviewers(pull_request, observers_ids,
+                                      PullRequestReviewers.ROLE_OBSERVER, user)
+
     def notify_users(self, pull_request, updating_user, ancestor_commit_id,
                      commit_changes, file_changes):
 
         updating_user_id = updating_user.user_id
         reviewers = set([x.user.user_id for x in pull_request.reviewers])
         # NOTE(marcink): send notification to all other users except to
         # person who updated the PR
         recipients = reviewers.difference(set([updating_user_id]))
 
         log.debug('Notify following recipients about pull-request update %s', recipients)
 
         pull_request_obj = pull_request
 
         # send email about the update
         changed_files = (
                 file_changes.added + file_changes.modified + file_changes.removed)
 
         pr_source_repo = pull_request_obj.source_repo
         pr_target_repo = pull_request_obj.target_repo
 
         pr_url = h.route_url('pullrequest_show',
                              repo_name=pr_target_repo.repo_name,
                              pull_request_id=pull_request_obj.pull_request_id,)
 
         # set some variables for email notification
         pr_target_repo_url = h.route_url(
             'repo_summary', repo_name=pr_target_repo.repo_name)
 
         pr_source_repo_url = h.route_url(
             'repo_summary', repo_name=pr_source_repo.repo_name)
 
         email_kwargs = {
             'date': datetime.datetime.now(),
             'updating_user': updating_user,
 
             'pull_request': pull_request_obj,
 
             'pull_request_target_repo': pr_target_repo,
             'pull_request_target_repo_url': pr_target_repo_url,
 
             'pull_request_source_repo': pr_source_repo,
             'pull_request_source_repo_url': pr_source_repo_url,
 
             'pull_request_url': pr_url,
 
             'ancestor_commit_id': ancestor_commit_id,
             'added_commits': commit_changes.added,
             'removed_commits': commit_changes.removed,
             'changed_files': changed_files,
             'added_files': file_changes.added,
             'modified_files': file_changes.modified,
             'removed_files': file_changes.removed,
             'thread_ids': [pr_url],
         }
 
         (subject, _e, body_plaintext) = EmailNotificationModel().render_email(
             EmailNotificationModel.TYPE_PULL_REQUEST_UPDATE, **email_kwargs)
 
         # create notification objects, and emails
         NotificationModel().create(
             created_by=updating_user,
             notification_subject=subject,
             notification_body=body_plaintext,
             notification_type=EmailNotificationModel.TYPE_PULL_REQUEST_UPDATE,
             recipients=recipients,
             email_kwargs=email_kwargs,
         )
 
     def delete(self, pull_request, user=None):
         if not user:
             user = getattr(get_current_rhodecode_user(), 'username', None)
 
         pull_request = self.__get_pull_request(pull_request)
         old_data = pull_request.get_api_data(with_merge_state=False)
         self._cleanup_merge_workspace(pull_request)
         self._log_audit_action(
             'repo.pull_request.delete', {'old_data': old_data},
             user, pull_request)
         Session().delete(pull_request)
 
     def close_pull_request(self, pull_request, user):
         pull_request = self.__get_pull_request(pull_request)
         self._cleanup_merge_workspace(pull_request)
         pull_request.status = PullRequest.STATUS_CLOSED
         pull_request.updated_on = datetime.datetime.now()
         Session().add(pull_request)
         self.trigger_pull_request_hook(pull_request, pull_request.author, 'close')
 
         pr_data = pull_request.get_api_data(with_merge_state=False)
         self._log_audit_action(
             'repo.pull_request.close', {'data': pr_data}, user, pull_request)
 
     def close_pull_request_with_comment(
             self, pull_request, user, repo, message=None, auth_user=None):
 
         pull_request_review_status = pull_request.calculated_review_status()
 
         if pull_request_review_status == ChangesetStatus.STATUS_APPROVED:
             # approved only if we have voting consent
             status = ChangesetStatus.STATUS_APPROVED
         else:
             status = ChangesetStatus.STATUS_REJECTED
         status_lbl = ChangesetStatus.get_status_lbl(status)
 
         default_message = (
             'Closing with status change {transition_icon} {status}.'
         ).format(transition_icon='>', status=status_lbl)
         text = message or default_message
 
         # create a comment, and link it to new status
         comment = CommentsModel().create(
             text=text,
             repo=repo.repo_id,
             user=user.user_id,
             pull_request=pull_request.pull_request_id,
             status_change=status_lbl,
             status_change_type=status,
             closing_pr=True,
             auth_user=auth_user,
         )
 
         # calculate old status before we change it
         old_calculated_status = pull_request.calculated_review_status()
         ChangesetStatusModel().set_status(
             repo.repo_id,
             status,
             user.user_id,
             comment=comment,
             pull_request=pull_request.pull_request_id
         )
 
         Session().flush()
 
         self.trigger_pull_request_hook(pull_request, user, 'comment',
                                        data={'comment': comment})
 
         # we now calculate the status of pull request again, and based on that
         # calculation trigger status change. This might happen in cases
         # that non-reviewer admin closes a pr, which means his vote doesn't
         # change the status, while if he's a reviewer this might change it.
         calculated_status = pull_request.calculated_review_status()
         if old_calculated_status != calculated_status:
             self.trigger_pull_request_hook(pull_request, user, 'review_status_change',
                                            data={'status': calculated_status})
 
         # finally close the PR
         PullRequestModel().close_pull_request(pull_request.pull_request_id, user)
 
         return comment, status
 
     def merge_status(self, pull_request, translator=None, force_shadow_repo_refresh=False):
         _ = translator or get_current_request().translate
 
         if not self._is_merge_enabled(pull_request):
             return None, False, _('Server-side pull request merging is disabled.')
 
         if pull_request.is_closed():
             return None, False, _('This pull request is closed.')
 
         merge_possible, msg = self._check_repo_requirements(
             target=pull_request.target_repo, source=pull_request.source_repo,
             translator=_)
         if not merge_possible:
             return None, merge_possible, msg
 
         try:
             merge_response = self._try_merge(
                 pull_request, force_shadow_repo_refresh=force_shadow_repo_refresh)
             log.debug("Merge response: %s", merge_response)
             return merge_response, merge_response.possible, merge_response.merge_status_message
         except NotImplementedError:
             return None, False, _('Pull request merging is not supported.')
 
     def _check_repo_requirements(self, target, source, translator):
         """
         Check if `target` and `source` have compatible requirements.
 
         Currently this is just checking for largefiles.
         """
         _ = translator
         target_has_largefiles = self._has_largefiles(target)
         source_has_largefiles = self._has_largefiles(source)
         merge_possible = True
         message = u''
 
         if target_has_largefiles != source_has_largefiles:
             merge_possible = False
             if source_has_largefiles:
                 message = _(
                     'Target repository large files support is disabled.')
             else:
                 message = _(
                     'Source repository large files support is disabled.')
 
         return merge_possible, message
 
     def _has_largefiles(self, repo):
         largefiles_ui = VcsSettingsModel(repo=repo).get_ui_settings(
             'extensions', 'largefiles')
         return largefiles_ui and largefiles_ui[0].active
 
     def _try_merge(self, pull_request, force_shadow_repo_refresh=False):
         """
         Try to merge the pull request and return the merge status.
         """
         log.debug(
             "Trying out if the pull request %s can be merged. Force_refresh=%s",
             pull_request.pull_request_id, force_shadow_repo_refresh)
         target_vcs = pull_request.target_repo.scm_instance()
         # Refresh the target reference.
         try:
             target_ref = self._refresh_reference(
                 pull_request.target_ref_parts, target_vcs)
         except CommitDoesNotExistError:
             merge_state = MergeResponse(
                 False, False, None, MergeFailureReason.MISSING_TARGET_REF,
                 metadata={'target_ref': pull_request.target_ref_parts})
             return merge_state
 
         target_locked = pull_request.target_repo.locked
         if target_locked and target_locked[0]:
             locked_by = 'user:{}'.format(target_locked[0])
             log.debug("The target repository is locked by %s.", locked_by)
             merge_state = MergeResponse(
                 False, False, None, MergeFailureReason.TARGET_IS_LOCKED,
                 metadata={'locked_by': locked_by})
         elif force_shadow_repo_refresh or self._needs_merge_state_refresh(
                 pull_request, target_ref):
             log.debug("Refreshing the merge status of the repository.")
             merge_state = self._refresh_merge_state(
                 pull_request, target_vcs, target_ref)
         else:
             possible = pull_request.last_merge_status == MergeFailureReason.NONE
             metadata = {
                 'unresolved_files': '',
                 'target_ref': pull_request.target_ref_parts,
                 'source_ref': pull_request.source_ref_parts,
             }
             if pull_request.last_merge_metadata:
                 metadata.update(pull_request.last_merge_metadata_parsed)
 
             if not possible and target_ref.type == 'branch':
                 # NOTE(marcink): case for mercurial multiple heads on branch
                 heads = target_vcs._heads(target_ref.name)
                 if len(heads) != 1:
                     heads = '\n,'.join(target_vcs._heads(target_ref.name))
                     metadata.update({
                         'heads': heads
                     })
 
             merge_state = MergeResponse(
                 possible, False, None, pull_request.last_merge_status, metadata=metadata)
 
         return merge_state
 
     def _refresh_reference(self, reference, vcs_repository):
         if reference.type in self.UPDATABLE_REF_TYPES:
             name_or_id = reference.name
         else:
             name_or_id = reference.commit_id
 
         refreshed_commit = vcs_repository.get_commit(name_or_id)
         refreshed_reference = Reference(
             reference.type, reference.name, refreshed_commit.raw_id)
         return refreshed_reference
 
     def _needs_merge_state_refresh(self, pull_request, target_reference):
         return not(
             pull_request.revisions and
             pull_request.revisions[0] == pull_request._last_merge_source_rev and
             target_reference.commit_id == pull_request._last_merge_target_rev)
 
     def _refresh_merge_state(self, pull_request, target_vcs, target_reference):
         workspace_id = self._workspace_id(pull_request)
         source_vcs = pull_request.source_repo.scm_instance()
         repo_id = pull_request.target_repo.repo_id
         use_rebase = self._use_rebase_for_merging(pull_request)
         close_branch = self._close_branch_before_merging(pull_request)
         merge_state = target_vcs.merge(
             repo_id, workspace_id,
             target_reference, source_vcs, pull_request.source_ref_parts,
             dry_run=True, use_rebase=use_rebase,
             close_branch=close_branch)
 
         # Do not store the response if there was an unknown error.
         if merge_state.failure_reason != MergeFailureReason.UNKNOWN:
             pull_request._last_merge_source_rev = \
                 pull_request.source_ref_parts.commit_id
             pull_request._last_merge_target_rev = target_reference.commit_id
             pull_request.last_merge_status = merge_state.failure_reason
             pull_request.last_merge_metadata = merge_state.metadata
 
             pull_request.shadow_merge_ref = merge_state.merge_ref
             Session().add(pull_request)
             Session().commit()
 
         return merge_state
 
     def _workspace_id(self, pull_request):
         workspace_id = 'pr-%s' % pull_request.pull_request_id
         return workspace_id
 
     def generate_repo_data(self, repo, commit_id=None, branch=None,
                            bookmark=None, translator=None):
         from rhodecode.model.repo import RepoModel
 
         all_refs, selected_ref = \
             self._get_repo_pullrequest_sources(
                 repo.scm_instance(), commit_id=commit_id,
                 branch=branch, bookmark=bookmark, translator=translator)
 
         refs_select2 = []
         for element in all_refs:
             children = [{'id': x[0], 'text': x[1]} for x in element[0]]
             refs_select2.append({'text': element[1], 'children': children})
 
         return {
             'user': {
                 'user_id': repo.user.user_id,
                 'username': repo.user.username,
                 'firstname': repo.user.first_name,
                 'lastname': repo.user.last_name,
                 'gravatar_link': h.gravatar_url(repo.user.email, 14),
             },
             'name': repo.repo_name,
             'link': RepoModel().get_url(repo),
             'description': h.chop_at_smart(repo.description_safe, '\n'),
             'refs': {
                 'all_refs': all_refs,
                 'selected_ref': selected_ref,
                 'select2_refs': refs_select2
             }
         }
 
     def generate_pullrequest_title(self, source, source_ref, target):
         return u'{source}#{at_ref} to {target}'.format(
             source=source,
             at_ref=source_ref,
             target=target,
         )
 
     def _cleanup_merge_workspace(self, pull_request):
         # Merging related cleanup
         repo_id = pull_request.target_repo.repo_id
         target_scm = pull_request.target_repo.scm_instance()
         workspace_id = self._workspace_id(pull_request)
 
         try:
             target_scm.cleanup_merge_workspace(repo_id, workspace_id)
         except NotImplementedError:
             pass
 
     def _get_repo_pullrequest_sources(
             self, repo, commit_id=None, branch=None, bookmark=None,
             translator=None):
         """
         Return a structure with repo's interesting commits, suitable for
         the selectors in pullrequest controller
 
         :param commit_id: a commit that must be in the list somehow
             and selected by default
         :param branch: a branch that must be in the list and selected
             by default - even if closed
         :param bookmark: a bookmark that must be in the list and selected
         """
         _ = translator or get_current_request().translate
 
         commit_id = safe_str(commit_id) if commit_id else None
         branch = safe_unicode(branch) if branch else None
         bookmark = safe_unicode(bookmark) if bookmark else None
 
         selected = None
 
         # order matters: first source that has commit_id in it will be selected
         sources = []
         sources.append(('book', repo.bookmarks.items(), _('Bookmarks'), bookmark))
         sources.append(('branch', repo.branches.items(), _('Branches'), branch))
 
         if commit_id:
             ref_commit = (h.short_id(commit_id), commit_id)
             sources.append(('rev', [ref_commit], _('Commit IDs'), commit_id))
 
         sources.append(
             ('branch', repo.branches_closed.items(), _('Closed Branches'), branch),
         )
 
         groups = []
 
         for group_key, ref_list, group_name, match in sources:
             group_refs = []
             for ref_name, ref_id in ref_list:
                 ref_key = u'{}:{}:{}'.format(group_key, ref_name, ref_id)
                 group_refs.append((ref_key, ref_name))
 
                 if not selected:
                     if set([commit_id, match]) & set([ref_id, ref_name]):
                         selected = ref_key
 
             if group_refs:
                 groups.append((group_refs, group_name))
 
         if not selected:
             ref = commit_id or branch or bookmark
             if ref:
                 raise CommitDoesNotExistError(
                     u'No commit refs could be found matching: {}'.format(ref))
             elif repo.DEFAULT_BRANCH_NAME in repo.branches:
                 selected = u'branch:{}:{}'.format(
                     safe_unicode(repo.DEFAULT_BRANCH_NAME),
                     safe_unicode(repo.branches[repo.DEFAULT_BRANCH_NAME])
                 )
             elif repo.commit_ids:
                 # make the user select in this case
                 selected = None
             else:
                 raise EmptyRepositoryError()
         return groups, selected
 
     def get_diff(self, source_repo, source_ref_id, target_ref_id,
                  hide_whitespace_changes, diff_context):
 
         return self._get_diff_from_pr_or_version(
             source_repo, source_ref_id, target_ref_id,
             hide_whitespace_changes=hide_whitespace_changes, diff_context=diff_context)
 
     def _get_diff_from_pr_or_version(
             self, source_repo, source_ref_id, target_ref_id,
             hide_whitespace_changes, diff_context):
 
         target_commit = source_repo.get_commit(
             commit_id=safe_str(target_ref_id))
         source_commit = source_repo.get_commit(
             commit_id=safe_str(source_ref_id), maybe_unreachable=True)
         if isinstance(source_repo, Repository):
             vcs_repo = source_repo.scm_instance()
         else:
             vcs_repo = source_repo
 
         # TODO: johbo: In the context of an update, we cannot reach
         # the old commit anymore with our normal mechanisms. It needs
         # some sort of special support in the vcs layer to avoid this
         # workaround.
         if (source_commit.raw_id == vcs_repo.EMPTY_COMMIT_ID and
                 vcs_repo.alias == 'git'):
             source_commit.raw_id = safe_str(source_ref_id)
 
         log.debug('calculating diff between '
                   'source_ref:%s and target_ref:%s for repo `%s`',
                   target_ref_id, source_ref_id,
                   safe_unicode(vcs_repo.path))
 
         vcs_diff = vcs_repo.get_diff(
             commit1=target_commit, commit2=source_commit,
             ignore_whitespace=hide_whitespace_changes, context=diff_context)
         return vcs_diff
 
     def _is_merge_enabled(self, pull_request):
         return self._get_general_setting(
             pull_request, 'rhodecode_pr_merge_enabled')
 
     def _use_rebase_for_merging(self, pull_request):
         repo_type = pull_request.target_repo.repo_type
         if repo_type == 'hg':
             return self._get_general_setting(
                 pull_request, 'rhodecode_hg_use_rebase_for_merging')
         elif repo_type == 'git':
             return self._get_general_setting(
                 pull_request, 'rhodecode_git_use_rebase_for_merging')
 
         return False
 
     def _user_name_for_merging(self, pull_request, user):
         env_user_name_attr = os.environ.get('RC_MERGE_USER_NAME_ATTR', '')
         if env_user_name_attr and hasattr(user, env_user_name_attr):
             user_name_attr = env_user_name_attr
         else:
             user_name_attr = 'short_contact'
 
         user_name = getattr(user, user_name_attr)
         return user_name
 
     def _close_branch_before_merging(self, pull_request):
         repo_type = pull_request.target_repo.repo_type
         if repo_type == 'hg':
             return self._get_general_setting(
                 pull_request, 'rhodecode_hg_close_branch_before_merging')
         elif repo_type == 'git':
             return self._get_general_setting(
                 pull_request, 'rhodecode_git_close_branch_before_merging')
 
         return False
 
     def _get_general_setting(self, pull_request, settings_key, default=False):
         settings_model = VcsSettingsModel(repo=pull_request.target_repo)
         settings = settings_model.get_general_settings()
         return settings.get(settings_key, default)
 
     def _log_audit_action(self, action, action_data, user, pull_request):
         audit_logger.store(
             action=action,
             action_data=action_data,
             user=user,
             repo=pull_request.target_repo)
 
     def get_reviewer_functions(self):
         """
         Fetches functions for validation and fetching default reviewers.
         If available we use the EE package, else we fallback to CE
         package functions
         """
         try:
             from rc_reviewers.utils import get_default_reviewers_data
             from rc_reviewers.utils import validate_default_reviewers
+            from rc_reviewers.utils import validate_observers
         except ImportError:
             from rhodecode.apps.repository.utils import get_default_reviewers_data
             from rhodecode.apps.repository.utils import validate_default_reviewers
+            from rhodecode.apps.repository.utils import validate_observers
 
-        return get_default_reviewers_data, validate_default_reviewers
+        return get_default_reviewers_data, validate_default_reviewers, validate_observers
 
 
 class MergeCheck(object):
     """
     Perform Merge Checks and returns a check object which stores information
     about merge errors, and merge conditions
     """
     TODO_CHECK = 'todo'
     PERM_CHECK = 'perm'
     REVIEW_CHECK = 'review'
     MERGE_CHECK = 'merge'
     WIP_CHECK = 'wip'
 
     def __init__(self):
         self.review_status = None
         self.merge_possible = None
         self.merge_msg = ''
         self.merge_response = None
         self.failed = None
         self.errors = []
         self.error_details = OrderedDict()
         self.source_commit = AttributeDict()
         self.target_commit = AttributeDict()
 
     def __repr__(self):
         return '<MergeCheck(possible:{}, failed:{}, errors:{})>'.format(
             self.merge_possible, self.failed, self.errors)
 
     def push_error(self, error_type, message, error_key, details):
         self.failed = True
         self.errors.append([error_type, message])
         self.error_details[error_key] = dict(
             details=details,
             error_type=error_type,
             message=message
         )
 
     @classmethod
     def validate(cls, pull_request, auth_user, translator, fail_early=False,
                  force_shadow_repo_refresh=False):
         _ = translator
         merge_check = cls()
 
         # title has WIP:
         if pull_request.work_in_progress:
             log.debug("MergeCheck: cannot merge, title has wip: marker.")
 
             msg = _('WIP marker in title prevents from accidental merge.')
             merge_check.push_error('error', msg, cls.WIP_CHECK, pull_request.title)
             if fail_early:
                 return merge_check
 
         # permissions to merge
         user_allowed_to_merge = PullRequestModel().check_user_merge(pull_request, auth_user)
         if not user_allowed_to_merge:
             log.debug("MergeCheck: cannot merge, approval is pending.")
 
             msg = _('User `{}` not allowed to perform merge.').format(auth_user.username)
             merge_check.push_error('error', msg, cls.PERM_CHECK, auth_user.username)
             if fail_early:
                 return merge_check
 
         # permission to merge into the target branch
         target_commit_id = pull_request.target_ref_parts.commit_id
         if pull_request.target_ref_parts.type == 'branch':
             branch_name = pull_request.target_ref_parts.name
         else:
             # for mercurial we can always figure out the branch from the commit
             # in case of bookmark
             target_commit = pull_request.target_repo.get_commit(target_commit_id)
             branch_name = target_commit.branch
 
         rule, branch_perm = auth_user.get_rule_and_branch_permission(
             pull_request.target_repo.repo_name, branch_name)
         if branch_perm and branch_perm == 'branch.none':
             msg = _('Target branch `{}` changes rejected by rule {}.').format(
                 branch_name, rule)
             merge_check.push_error('error', msg, cls.PERM_CHECK, auth_user.username)
             if fail_early:
                 return merge_check
 
         # review status, must be always present
         review_status = pull_request.calculated_review_status()
         merge_check.review_status = review_status
 
         status_approved = review_status == ChangesetStatus.STATUS_APPROVED
         if not status_approved:
             log.debug("MergeCheck: cannot merge, approval is pending.")
 
             msg = _('Pull request reviewer approval is pending.')
 
             merge_check.push_error('warning', msg, cls.REVIEW_CHECK, review_status)
 
             if fail_early:
                 return merge_check
 
         # left over TODOs
         todos = CommentsModel().get_pull_request_unresolved_todos(pull_request)
         if todos:
             log.debug("MergeCheck: cannot merge, {} "
                       "unresolved TODOs left.".format(len(todos)))
 
             if len(todos) == 1:
                 msg = _('Cannot merge, {} TODO still not resolved.').format(
                     len(todos))
             else:
                 msg = _('Cannot merge, {} TODOs still not resolved.').format(
                     len(todos))
 
             merge_check.push_error('warning', msg, cls.TODO_CHECK, todos)
 
             if fail_early:
                 return merge_check
 
         # merge possible, here is the filesystem simulation + shadow repo
         merge_response, merge_status, msg = PullRequestModel().merge_status(
             pull_request, translator=translator,
             force_shadow_repo_refresh=force_shadow_repo_refresh)
 
         merge_check.merge_possible = merge_status
         merge_check.merge_msg = msg
         merge_check.merge_response = merge_response
 
         source_ref_id = pull_request.source_ref_parts.commit_id
         target_ref_id = pull_request.target_ref_parts.commit_id
 
         try:
             source_commit, target_commit = PullRequestModel().get_flow_commits(pull_request)
             merge_check.source_commit.changed = source_ref_id != source_commit.raw_id
             merge_check.source_commit.ref_spec = pull_request.source_ref_parts
             merge_check.source_commit.current_raw_id = source_commit.raw_id
             merge_check.source_commit.previous_raw_id = source_ref_id
 
             merge_check.target_commit.changed = target_ref_id != target_commit.raw_id
             merge_check.target_commit.ref_spec = pull_request.target_ref_parts
             merge_check.target_commit.current_raw_id = target_commit.raw_id
             merge_check.target_commit.previous_raw_id = target_ref_id
         except (SourceRefMissing, TargetRefMissing):
             pass
 
         if not merge_status:
             log.debug("MergeCheck: cannot merge, pull request merge not possible.")
             merge_check.push_error('warning', msg, cls.MERGE_CHECK, None)
 
             if fail_early:
                 return merge_check
 
         log.debug('MergeCheck: is failed: %s', merge_check.failed)
         return merge_check
 
     @classmethod
     def get_merge_conditions(cls, pull_request, translator):
         _ = translator
         merge_details = {}
 
         model = PullRequestModel()
         use_rebase = model._use_rebase_for_merging(pull_request)
 
         if use_rebase:
             merge_details['merge_strategy'] = dict(
                 details={},
                 message=_('Merge strategy: rebase')
             )
         else:
             merge_details['merge_strategy'] = dict(
                 details={},
                 message=_('Merge strategy: explicit merge commit')
             )
 
         close_branch = model._close_branch_before_merging(pull_request)
         if close_branch:
             repo_type = pull_request.target_repo.repo_type
             close_msg = ''
             if repo_type == 'hg':
                 close_msg = _('Source branch will be closed before the merge.')
             elif repo_type == 'git':
                 close_msg = _('Source branch will be deleted after the merge.')
 
             merge_details['close_branch'] = dict(
                 details={},
                 message=close_msg
             )
 
         return merge_details
 
 
 ChangeTuple = collections.namedtuple(
     'ChangeTuple', ['added', 'common', 'removed', 'total'])
 
 FileChangeTuple = collections.namedtuple(
     'FileChangeTuple', ['added', 'modified', 'removed'])

rhodecode/public/css/main.less

@@ -1,3211 +1,3236 b''
 //Primary CSS
 
 //--- IMPORTS ------------------//
 
 @import 'helpers';
 @import 'mixins';
 @import 'rcicons';
 @import 'variables';
 @import 'bootstrap-variables';
 @import 'form-bootstrap';
 @import 'codemirror';
 @import 'legacy_code_styles';
 @import 'readme-box';
 @import 'progress-bar';
 
 @import 'type';
 @import 'alerts';
 @import 'buttons';
 @import 'tags';
 @import 'code-block';
 @import 'examples';
 @import 'login';
 @import 'main-content';
 @import 'select2';
 @import 'comments';
 @import 'panels-bootstrap';
 @import 'panels';
 @import 'deform';
 @import 'tooltips';
 @import 'sweetalert2';
 
 
 //--- BASE ------------------//
 .noscript-error {
   top: 0;
   left: 0;
   width: 100%;
   z-index: 101;
   text-align: center;
   font-size: 120%;
   color: white;
   background-color: @alert2;
   padding: 5px 0 5px 0;
   font-weight: @text-semibold-weight;
   font-family: @text-semibold;
 }
 
 html {
     display: table;
     height: 100%;
     width: 100%;
 }
 
 body {
     display: table-cell;
     width: 100%;
 }
 
 //--- LAYOUT ------------------//
 
 .hidden{
 	display: none !important;
 }
 
 .box{
 	float: left;
 	width: 100%;
 }
 
 .browser-header {
     clear: both;
 }
 .main {
   clear: both;
   padding:0 0 @pagepadding;
   height: auto;
 
 	&:after { //clearfix
 		content:"";
 		clear:both;
 		width:100%;
 		display:block;
 	}
 }
 
 .flex-container {
     display: flex;
     justify-content: space-between;
 }
 
 .action-link{
 	margin-left: @padding;
 	padding-left: @padding;
 	border-left: @border-thickness solid @border-default-color;
 }
 
 .cursor-pointer {
   cursor: pointer;
 }
 
 input + .action-link, .action-link.first{
 	border-left: none;
 }
 
 .link-disabled {
     color: @grey4;
     cursor: default;
 }
 
 .action-link.last{
 	margin-right: @padding;
 	padding-right: @padding;
 }
 
 .action-link.active,
 .action-link.active a{
 	color: @grey4;
 }
 
 .action-link.disabled {
     color: @grey4;
     cursor: inherit;
 }
 
 .grey-link-action {
   cursor: pointer;
   &:hover {
       color: @grey2;
   }
   color: @grey4;
 }
 
 .clipboard-action {
   cursor: pointer;
   margin-left: 5px;
 
   &:not(.no-grey) {
 
     &:hover {
       color: @grey2;
     }
     color: @grey4;
   }
 }
 
 ul.simple-list{
 	list-style: none;
 	margin: 0;
 	padding: 0;
 }
 
 .main-content {
 	padding-bottom: @pagepadding;
 }
 
 .wide-mode-wrapper {
     max-width:4000px !important;
 }
 
 .wrapper {
 	position: relative;
 	max-width: @wrapper-maxwidth;
 	margin: 0 auto;
 }
 
 #content {
     clear: both;
     padding: 0 @contentpadding;
 }
 
 .advanced-settings-fields{
 	input{
 		margin-left: @textmargin;
 		margin-right: @padding/2;
 	}
 }
 
 .cs_files_title {
     margin: @pagepadding 0 0;
 }
 
 input.inline[type="file"] {
 	display: inline;
 }
 
 .error_page {
     margin: 10% auto;
 
     h1 {
         color: @grey2;
     }
 
     .alert {
         margin: @padding 0;
     }
 
     .error-branding {
       color: @grey4;
       font-weight: @text-semibold-weight;
       font-family: @text-semibold;
     }
 
     .error_message {
         font-family: @text-regular;
     }
 
     .sidebar {
         min-height: 275px;
         margin: 0;
         padding: 0 0 @sidebarpadding @sidebarpadding;
         border: none;
     }
 
     .main-content {
         position: relative;
         margin: 0 @sidebarpadding @sidebarpadding;
         padding: 0 0 0 @sidebarpadding;
         border-left: @border-thickness solid @grey5;
 
         @media (max-width:767px) {
             clear: both;
             width: 100%;
             margin: 0;
             border: none;
         }
     }
 
     .inner-column {
         float: left;
         width: 29.75%;
         min-height: 150px;
         margin: @sidebarpadding 2% 0 0;
         padding: 0 2% 0 0;
         border-right: @border-thickness solid @grey5;
 
         @media (max-width:767px) {
             clear: both;
             width: 100%;
             border: none;
         }
 
         ul {
             padding-left: 1.25em;
         }
 
         &:last-child {
             margin: @sidebarpadding 0 0;
             border: none;
         }
 
         h4 {
           margin: 0 0 @padding;
           font-weight: @text-semibold-weight;
           font-family: @text-semibold;
         }
     }
 }
 .error-page-logo {
     width: 130px;
     height: 160px;
 }
 
 // HEADER
 .header {
 
     // TODO: johbo: Fix login pages, so that they work without a min-height
     // for the header and then remove the min-height. I chose a smaller value
     // intentionally here to avoid rendering issues in the main navigation.
     min-height: 49px;
     min-width: 1024px;
 
 	position: relative;
 	vertical-align: bottom;
 	padding: 0 @header-padding;
 	background-color: @grey1;
 	color: @grey5;
 
 	.title {
 		overflow: visible;
 	}
 
 	&:before,
 	&:after {
 		content: "";
 		clear: both;
 		width: 100%;
 	}
 
 	// TODO: johbo: Avoids breaking "Repositories" chooser
 	.select2-container .select2-choice .select2-arrow {
 	    display: none;
 	}
 }
 
 #header-inner {
 	&.title {
 		margin: 0;
 	}
 	&:before,
 	&:after {
 		content: "";
 		clear: both;
 	}
 }
 
 // Gists
 #files_data {
     clear: both; //for firefox
     padding-top: 10px;
 }
 
 #gistid {
     margin-right: @padding;
 }
 
 // Global Settings Editor
 .textarea.editor {
 	float: left;
 	position: relative;
 	max-width: @texteditor-width;
 
 	select {
 		position: absolute;
 		top:10px;
 		right:0;
 	}
 
 	.CodeMirror {
 		margin: 0;
 	}
 
 	.help-block {
 		margin: 0 0 @padding;
 		padding:.5em;
 		background-color: @grey6;
         &.pre-formatting {
             white-space: pre;
         }
 	}
 }
 
 ul.auth_plugins {
 	margin: @padding 0 @padding @legend-width;
 	padding: 0;
 
 	li {
 		margin-bottom: @padding;
         line-height: 1em;
 		list-style-type: none;
 
 		.auth_buttons .btn {
 			margin-right: @padding;
 		}
 
 	}
 }
 
 
 // My Account PR list
 
 #show_closed {
     margin: 0 1em 0 0;
 }
 
 #pull_request_list_table {
     .closed {
         background-color: @grey6;
     }
 
     .state-creating,
     .state-updating,
     .state-merging
     {
         background-color: @grey6;
     }
 
     .td-status {
         padding-left: .5em;
     }
     .log-container .truncate {
         height: 2.75em;
         white-space: pre-line;
     }
     table.rctable .user {
         padding-left: 0;
     }
     table.rctable {
         td.td-description,
         .rc-user {
             min-width: auto;
         }
     }
 }
 
 // Pull Requests
 
 .pullrequests_section_head {
   display: block;
   clear: both;
   margin: @padding 0;
   font-weight: @text-bold-weight;
   font-family: @text-bold;
 }
 
 .pr-commit-flow  {
     position: relative;
     font-weight: 600;
 
     .tag {
         display: inline-block;
         margin: 0 1em .5em 0;
     }
 
     .clone-url {
         display: inline-block;
         margin: 0 0 .5em 0;
         padding: 0;
         line-height: 1.2em;
     }
 }
 
 .pr-mergeinfo {
       min-width: 95% !important;
       padding: 0 !important;
       border: 0;
 }
 .pr-mergeinfo-copy {
     padding: 0 0;
 }
 
 .pr-pullinfo {
       min-width: 95% !important;
       padding: 0 !important;
       border: 0;
 }
 .pr-pullinfo-copy {
     padding: 0 0;
 }
 
 .pr-title-input {
   width: 100%;
   font-size: 18px;
   margin:  0 0 4px 0;
   padding: 0;
   line-height: 1.7em;
   color: @text-color;
   letter-spacing: .02em;
   font-weight: @text-bold-weight;
   font-family: @text-bold;
 
   &:hover {
     box-shadow: none;
   }
 }
 
 #pr-title {
   input {
     border: 1px transparent;
     color: black;
     opacity: 1;
     background: #fff;
     font-size: 18px;
   }
 }
 
 .pr-title-closed-tag {
     font-size: 16px;
 }
 
 #pr-desc {
   padding: 10px 0;
 
   .markdown-block {
     padding: 0;
     margin-bottom: -30px;
   }
 }
 
 #pullrequest_title {
     width: 100%;
     box-sizing: border-box;
 }
 
 #pr_open_message {
     border: @border-thickness solid #fff;
     border-radius: @border-radius;
     text-align: left;
     overflow: hidden;
     white-space: pre-line;
     padding-top: 5px
 }
 
 #add_reviewer {
     padding-top: 10px;
 }
 
 #add_reviewer_input {
     padding-top: 10px
 }
 
 .pr-details-title-author-pref {
     padding-right: 10px
 }
 
 .label-pr-detail {
   display: table-cell;
   width: 120px;
   padding-top: 7.5px;
   padding-bottom: 7.5px;
   padding-right: 7.5px;
 }
 
 .source-details ul {
   padding: 10px 16px;
 }
 
 .source-details-action {
   color: @grey4;
   font-size: 11px
 }
 
 .pr-submit-button {
     float: right;
     margin: 0 0 0 5px;
 }
 
 .pr-spacing-container {
     padding: 20px;
     clear: both
 }
 
 #pr-description-input {
     margin-bottom: 0;
 }
 
 .pr-description-label {
     vertical-align: top;
 }
 
 #open_edit_pullrequest {
   padding: 0;
 }
 
 #close_edit_pullrequest {
 
 }
 
 #delete_pullrequest {
     clear: inherit;
 
   form {
       display: inline;
   }
 
 }
 
 .perms_section_head {
     min-width: 625px;
 
     h2 {
         margin-bottom: 0;
     }
 
     .label-checkbox {
         float: left;
     }
 
     &.field {
         margin: @space 0 @padding;
     }
 
     &:first-child.field {
         margin-top: 0;
 
         .label {
             margin-top: 0;
             padding-top: 0;
         }
 
         .radios {
             padding-top: 0;
         }
     }
 
     .radios {
         position: relative;
         width: 505px;
     }
 }
 
 //--- MODULES ------------------//
 
 
 // Server Announcement
 #server-announcement {
   width: 95%;
   margin: @padding auto;
   padding: @padding;
   border-width: 2px;
   border-style: solid;
   .border-radius(2px);
   font-weight: @text-bold-weight;
   font-family: @text-bold;
 
   &.info    { border-color: @alert4; background-color: @alert4-inner; }
   &.warning { border-color: @alert3; background-color: @alert3-inner; }
   &.error   { border-color: @alert2; background-color: @alert2-inner; }
   &.success { border-color: @alert1; background-color: @alert1-inner; }
   &.neutral { border-color: @grey3; background-color: @grey6; }
 }
 
 // Fixed Sidebar Column
 .sidebar-col-wrapper {
     padding-left: @sidebar-all-width;
 
     .sidebar {
         width: @sidebar-width;
         margin-left: -@sidebar-all-width;
     }
 }
 
 .sidebar-col-wrapper.scw-small {
     padding-left: @sidebar-small-all-width;
 
     .sidebar {
         width: @sidebar-small-width;
         margin-left: -@sidebar-small-all-width;
     }
 }
 
 
 // FOOTER
 #footer {
 	padding: 0;
 	text-align: center;
 	vertical-align: middle;
 	color: @grey2;
     font-size: 11px;
 
 	p {
 		margin: 0;
 		padding: 1em;
 		line-height: 1em;
 	}
 
 	.server-instance { //server instance
 		display: none;
 	}
 
 	.title {
 		float: none;
 		margin: 0 auto;
 	}
 }
 
 button.close {
 	padding: 0;
 	cursor: pointer;
 	background: transparent;
 	border: 0;
 	.box-shadow(none);
 	-webkit-appearance: none;
 }
 
 .close {
 	float: right;
 	font-size: 21px;
 	font-family: @text-bootstrap;
 	line-height: 1em;
 	font-weight: bold;
 	color: @grey2;
 
 	&:hover,
 	&:focus {
 		color: @grey1;
 		text-decoration: none;
 		cursor: pointer;
 	}
 }
 
 // GRID
 .sorting,
 .sorting_desc,
 .sorting_asc {
 	cursor: pointer;
 }
 .sorting_desc:after {
 	content: "\00A0\25B2";
 	font-size: .75em;
 }
 .sorting_asc:after {
 	content: "\00A0\25BC";
 	font-size: .68em;
 }
 
 
 .user_auth_tokens {
 
     &.truncate {
         white-space: nowrap;
         overflow: hidden;
         text-overflow: ellipsis;
     }
 
 	.fields .field .input {
 		margin: 0;
 	}
 
 	input#description {
 		width: 100px;
 		margin: 0;
 	}
 
 	.drop-menu {
 	    // TODO: johbo: Remove this, should work out of the box when
 	    // having multiple inputs inline
 		margin: 0 0 0 5px;
 	}
 }
 #user_list_table {
   .closed {
     background-color: @grey6;
   }
 }
 
 
 input, textarea {
 	&.disabled {
 		opacity: .5;
 	}
 
     &:hover {
         border-color: @grey3;
         box-shadow: @button-shadow;
     }
 
     &:focus {
         border-color: @rcblue;
         box-shadow: @button-shadow;
     }
 }
 
 // remove extra padding in firefox
 input::-moz-focus-inner { border:0; padding:0 }
 
 .adjacent input {
 	margin-bottom: @padding;
 }
 
 .permissions_boxes {
 	display: block;
 }
 
 //FORMS
 
 .medium-inline,
 input#description.medium-inline {
 	display: inline;
 	width: @medium-inline-input-width;
 	min-width: 100px;
 }
 
 select {
 	//reset
 	-webkit-appearance: none;
 	-moz-appearance: none;
 
 	display: inline-block;
 	height: 28px;
 	width: auto;
 	margin: 0 @padding @padding 0;
 	padding: 0 18px 0 8px;
 	line-height:1em;
 	font-size: @basefontsize;
 	border: @border-thickness solid @grey5;
     border-radius: @border-radius;
 	background:white url("../images/dt-arrow-dn.png") no-repeat 100% 50%;
 	color: @grey4;
     box-shadow: @button-shadow;
 
 	&:after {
 		content: "\00A0\25BE";
 	}
 
 	&:focus, &:hover {
 		outline: none;
         border-color: @grey4;
         color: @rcdarkblue;
 	}
 }
 
 option {
 	&:focus {
 		outline: none;
 	}
 }
 
 input,
 textarea {
 	padding: @input-padding;
 	border: @input-border-thickness solid @border-highlight-color;
 	.border-radius (@border-radius);
 	font-family: @text-light;
 	font-size: @basefontsize;
 
 	&.input-sm {
 		padding: 5px;
 	}
 
 	&#description {
 		min-width: @input-description-minwidth;
 		min-height: 1em;
 		padding: 10px;
 	}
 }
 
 .field-sm {
     input,
     textarea {
         padding: 5px;
     }
 }
 
 textarea {
 	display: block;
 	clear: both;
 	width: 100%;
 	min-height: 100px;
 	margin-bottom: @padding;
     .box-sizing(border-box);
     overflow: auto;
 }
 
 label {
 	font-family: @text-light;
 }
 
 // GRAVATARS
 // centers gravatar on username to the right
 
 .gravatar {
     display: inline;
     min-width: 16px;
     min-height: 16px;
     margin: -5px 0;
     padding: 0;
     line-height: 1em;
     box-sizing: content-box;
     border-radius: 50%;
 
     &.gravatar-large {
         margin: -0.5em .25em -0.5em 0;
     }
 
     & + .user {
         display: inline;
         margin: 0;
         padding: 0 0 0 .17em;
         line-height: 1em;
     }
 
     & + .no-margin {
       margin: 0
     }
 
 }
 
 .user-inline-data {
     display: inline-block;
     float: left;
     padding-left: .5em;
     line-height: 1.3em;
 }
 
 .rc-user { // gravatar + user wrapper
     float: left;
     position: relative;
     min-width: 100px;
     max-width: 200px;
     min-height: (@gravatar-size + @border-thickness * 2); // account for border
     display: block;
     padding: 0 0 0 (@gravatar-size  + @basefontsize/4);
 
 
     .gravatar {
         display: block;
         position: absolute;
         top: 0;
         left: 0;
         min-width:  @gravatar-size;
         min-height: @gravatar-size;
         margin: 0;
     }
 
     .user {
         display: block;
         max-width: 175px;
         padding-top: 2px;
         overflow: hidden;
         text-overflow: ellipsis;
     }
 }
 
 .gist-gravatar,
 .journal_container {
     .gravatar-large {
         margin: 0 .5em -10px 0;
     }
 }
 
 .gist-type-fields {
     line-height: 30px;
     height: 30px;
 
     .gist-type-fields-wrapper {
         vertical-align: middle;
         display: inline-block;
         line-height: 25px;
     }
 }
 
 // ADMIN SETTINGS
 
 // Tag Patterns
 .tag_patterns {
 	.tag_input {
 		margin-bottom: @padding;
 	}
 }
 
 .locked_input {
     position: relative;
 
     input {
         display: inline;
         margin: 3px 5px 0px 0px;
     }
 
     br {
         display: none;
     }
 
     .error-message {
         float: left;
         width: 100%;
     }
 
     .lock_input_button {
         display: inline;
     }
 
     .help-block {
         clear: both;
     }
 }
 
 // Notifications
 
 .notifications_buttons {
 	margin: 0 0 @space 0;
 	padding: 0;
 
 	.btn {
 		display: inline-block;
 	}
 }
 
 .notification-list {
 
 	div {
 		vertical-align: middle;
 	}
 
 	.container {
 		display: block;
 		margin: 0 0 @padding 0;
 	}
 
 	.delete-notifications {
 		margin-left: @padding;
 		text-align: right;
         cursor: pointer;
 	}
 
 	.read-notifications {
 		margin-left: @padding/2;
 		text-align: right;
 		width: 35px;
         cursor: pointer;
 	}
 
 	.icon-minus-sign {
 		color: @alert2;
 	}
 
 	.icon-ok-sign {
 		color: @alert1;
 	}
 }
 
 .user_settings {
 	float: left;
 	clear: both;
 	display: block;
 	width: 100%;
 
 	.gravatar_box {
 		margin-bottom: @padding;
 
 		&:after {
 			content: " ";
 			clear: both;
 			width: 100%;
 		}
 	}
 
 	.fields .field {
 		clear: both;
 	}
 }
 
 .advanced_settings {
 	margin-bottom: @space;
 
 	.help-block {
 		margin-left: 0;
 	}
 
 	button + .help-block {
 		margin-top: @padding;
 	}
 }
 
 // admin settings radio buttons and labels
 .label-2 {
 	float: left;
 	width: @label2-width;
 
 	label {
 		color: @grey1;
 	}
 }
 .checkboxes {
 	float: left;
 	width: @checkboxes-width;
 	margin-bottom: @padding;
 
 	.checkbox {
 		width: 100%;
 
 		label {
 			margin: 0;
 			padding: 0;
 		}
 	}
 
 	.checkbox + .checkbox {
 		display: inline-block;
 	}
 
 	label {
 		margin-right: 1em;
 	}
 }
 
 // CHANGELOG
 .container_header {
     float: left;
 	display: block;
 	width: 100%;
 	margin: @padding 0 @padding;
 
     #filter_changelog {
         float: left;
         margin-right: @padding;
     }
 
     .breadcrumbs_light {
         display: inline-block;
     }
 }
 
 .info_box {
 	float: right;
 }
 
 
 
 #graph_content{
 
     // adjust for table headers so that graph renders properly
     //           #graph_nodes padding - table cell padding
     padding-top: (@space - (@basefontsize * 2.4));
 
     &.graph_full_width {
         width: 100%;
         max-width: 100%;
     }
 }
 
 #graph {
 
     .pagination-left {
         float: left;
         clear: both;
     }
 
     .log-container {
         max-width: 345px;
 
         .message{
             max-width: 340px;
         }
     }
 
     .graph-col-wrapper {
 
         #graph_nodes {
             width: 100px;
             position: absolute;
             left: 70px;
             z-index: -1;
         }
     }
 
     .load-more-commits {
         text-align: center;
     }
     .load-more-commits:hover {
         background-color: @grey7;
     }
     .load-more-commits {
       a {
         display: block;
       }
     }
 }
 
 .obsolete-toggle {
     line-height: 30px;
     margin-left: -15px;
 }
 
 #rev_range_container, #rev_range_clear, #rev_range_more {
     margin-top: -5px;
     margin-bottom: -5px;
 }
 
 #filter_changelog {
     float: left;
 }
 
 
 //--- THEME ------------------//
 
 #logo {
 	float: left;
 	margin: 9px 0 0 0;
 
     .header {
     	background-color: transparent;
     }
 
     a {
     	display: inline-block;
     }
 
     img {
     	height:30px;
     }
 }
 
 .logo-wrapper {
 	float:left;
 }
 
 .branding {
 	float: left;
 	padding: 9px 2px;
 	line-height: 1em;
 	font-size: @navigation-fontsize;
 
     a {
       color: @grey5
     }
 
     // 1024px or smaller
     @media screen and (max-width: 1180px) {
       display: none;
     }
 
 }
 
 img {
 	border: none;
 	outline: none;
 }
  user-profile-header
 label {
 
     input[type="checkbox"] {
         margin-right: 1em;
     }
     input[type="radio"] {
         margin-right: 1em;
     }
 }
 
 .review-status {
     &.under_review {
         color: @alert3;
     }
     &.approved {
         color: @alert1;
     }
     &.rejected,
     &.forced_closed{
         color: @alert2;
     }
     &.not_reviewed {
         color: @grey5;
     }
 }
 
 .review-status-under_review {
   color: @alert3;
 }
 .status-tag-under_review {
   border-color: @alert3;
 }
 
 .review-status-approved {
   color: @alert1;
 }
 .status-tag-approved {
   border-color: @alert1;
 }
 
 .review-status-rejected,
 .review-status-forced_closed {
   color: @alert2;
 }
 .status-tag-rejected,
 .status-tag-forced_closed {
   border-color: @alert2;
 }
 
 .review-status-not_reviewed {
   color: @grey5;
 }
 .status-tag-not_reviewed {
   border-color: @grey5;
 }
 
 .test_pattern_preview {
 	margin: @space 0;
 
 	p {
         margin-bottom: 0;
 		border-bottom: @border-thickness solid @border-default-color;
 		color: @grey3;
 	}
 
 	.btn {
 		margin-bottom: @padding;
 	}
 }
 #test_pattern_result {
     display: none;
     &:extend(pre);
     padding: .9em;
     color: @grey3;
     background-color: @grey7;
     border-right: @border-thickness solid @border-default-color;
     border-bottom: @border-thickness solid @border-default-color;
     border-left: @border-thickness solid @border-default-color;
 }
 
 #repo_vcs_settings {
     #inherit_overlay_vcs_default {
         display: none;
     }
     #inherit_overlay_vcs_custom {
         display: custom;
     }
     &.inherited {
         #inherit_overlay_vcs_default {
             display: block;
         }
         #inherit_overlay_vcs_custom {
             display: none;
         }
     }
 }
 
 .issue-tracker-link {
 	color: @rcblue;
 }
 
 // Issue Tracker Table Show/Hide
 #repo_issue_tracker {
     #inherit_overlay {
         display: none;
     }
     #custom_overlay {
         display: custom;
     }
     &.inherited {
         #inherit_overlay {
             display: block;
         }
         #custom_overlay {
             display: none;
         }
     }
 }
 table.issuetracker {
     &.readonly {
         tr, td {
             color: @grey3;
         }
     }
     .edit {
         display: none;
     }
     .editopen {
         .edit {
             display: inline;
         }
         .entry {
             display: none;
         }
     }
     tr td.td-action {
         min-width: 117px;
     }
     td input {
         max-width: none;
         min-width: 30px;
         width: 80%;
     }
     .issuetracker_pref input {
         width: 40%;
     }
     input.edit_issuetracker_update {
         margin-right: 0;
         width: auto;
     }
 }
 
 table.integrations {
     .td-icon {
         width: 20px;
         .integration-icon {
             height: 20px;
             width: 20px;
         }
     }
 }
 
 .integrations {
     a.integration-box {
         color: @text-color;
         &:hover {
             .panel {
                 background: #fbfbfb;
             }
         }
         .integration-icon {
           width: 30px;
           height: 30px;
           margin-right: 20px;
           float: left;
         }
 
         .panel-body {
             padding: 10px;
         }
         .panel {
             margin-bottom: 10px;
         }
         h2 {
             display: inline-block;
             margin: 0;
             min-width: 140px;
         }
     }
     a.integration-box.dummy-integration {
       color: @grey4
     }
 }
 
 //Permissions Settings
 #add_perm {
     margin: 0 0 @padding;
 	cursor: pointer;
 }
 
 .perm_ac {
     input {
         width: 95%;
     }
 }
 
 .autocomplete-suggestions {
     width: auto !important; // overrides autocomplete.js
     min-width: 278px;
     margin: 0;
     border: @border-thickness solid @grey5;
     border-radius: @border-radius;
     color: @grey2;
     background-color: white;
 }
 
 .autocomplete-qfilter-suggestions {
     width: auto !important; // overrides autocomplete.js
     max-height: 100% !important;
     min-width: 376px;
     margin: 0;
     border: @border-thickness solid @grey5;
     color: @grey2;
     background-color: white;
 }
 
 .autocomplete-selected {
     background: #F0F0F0;
 }
 
 .ac-container-wrap {
 	margin: 0;
 	padding: 8px;
 	border-bottom: @border-thickness solid @grey5;
 	list-style-type: none;
 	cursor: pointer;
 
 		&:hover {
 			background-color: @grey7;
 	}
 
 	img {
         height: @gravatar-size;
         width: @gravatar-size;
 		margin-right: 1em;
 	}
 
 	strong {
 		font-weight: normal;
 	}
 }
 
 // Settings Dropdown
 .user-menu .container {
     padding: 0 4px;
     margin: 0;
 }
 
 .user-menu .gravatar {
     cursor: pointer;
 }
 
 .codeblock {
 	margin-bottom: @padding;
     clear: both;
 
     .stats {
         overflow: hidden;
     }
 
     .message{
         textarea{
             margin: 0;
         }
     }
 
     .code-header {
     	.stats {
             line-height: 2em;
 
     		.revision_id {
     			margin-left: 0;
     		}
 			.buttons {
                 padding-right: 0;
 			}
     	}
 
         .item{
             margin-right: 0.5em;
         }
     }
 
     #editor_container {
       position: relative;
       margin: @padding 10px;
     }
 }
 
 #file_history_container {
     display: none;
 }
 
 .file-history-inner {
     margin-bottom: 10px;
 }
 
 // Pull Requests
 .summary-details {
     width: 100%;
 }
 .pr-summary {
     border-bottom: @border-thickness solid @grey5;
     margin-bottom: @space;
 }
 
 .reviewers {
   width: 98%;
 }
 
 .reviewers ul li {
     position: relative;
     width: 100%;
     padding-bottom: 8px;
     list-style-type: none;
 }
 
 .reviewer_entry {
   min-height: 55px;
 }
 
 .reviewer_reason {
     padding-left: 20px;
     line-height: 1.5em;
 }
 .reviewer_status {
     display: inline-block;
     width: 20px;
     min-width: 20px;
     height: 1.2em;
     line-height: 1em;
 }
 
 .reviewer_name {
     display: inline-block;
     max-width: 83%;
     padding-right: 20px;
     vertical-align: middle;
     line-height: 1;
 
     .rc-user {
         min-width: 0;
         margin: -2px 1em 0 0;
     }
 
     .reviewer {
         float: left;
     }
 }
 
 .reviewer_member_mandatory {
     width: 16px;
     font-size: 11px;
     margin: 0;
     padding: 0;
     color: black;
     opacity: 0.4;
 }
 
 .reviewer_member_mandatory_remove,
 .reviewer_member_remove {
     width: 16px;
     padding: 0;
     color: black;
     cursor: pointer;
 }
 
 .reviewer_member_mandatory_remove {
   color: @grey4;
 }
 
 .reviewer_member_status {
     margin-top: 5px;
 }
 .pr-summary #summary{
     width: 100%;
 }
 .pr-summary .action_button:hover {
     border: 0;
     cursor: pointer;
 }
 .pr-details-title {
     height: 20px;
     line-height: 20px;
 
     padding-bottom: 8px;
     border-bottom: @border-thickness solid @grey5;
 
     .action_button.disabled {
         color: @grey4;
         cursor: inherit;
     }
     .action_button {
         color: @rcblue;
     }
 }
 .pr-details-content {
     margin-top: @textmargin - 5;
     margin-bottom: @textmargin - 5;
 }
 
 .pr-reviewer-rules {
    padding: 10px 0px 20px 0px;
 }
 
 .todo-resolved {
   text-decoration: line-through;
 }
 
 .todo-table, .comments-table {
   width: 100%;
 
   td {
     padding: 5px 0px;
   }
 
   .td-todo-number {
     text-align: left;
     white-space: nowrap;
     width: 1%;
     padding-right: 2px;
   }
 
   .td-todo-gravatar {
     width: 5%;
 
     img {
       margin: -3px 0;
     }
   }
 
 }
 
 .todo-comment-text-wrapper {
   display: inline-grid;
 }
 
 .todo-comment-text {
   margin-left: 5px;
   white-space: nowrap;
   overflow: hidden;
   text-overflow: ellipsis;
 }
 
 table.group_members {
   width: 100%
 }
 
 .group_members {
     margin-top: 0;
     padding: 0;
 
     img {
         height: @gravatar-size;
         width: @gravatar-size;
         margin-right: .5em;
         margin-left: 3px;
     }
 
     .to-delete {
         .user {
           text-decoration: line-through;
         }
     }
 }
 
 .compare_view_commits_title {
   .disabled {
     cursor: inherit;
     &:hover{
       background-color: inherit;
       color: inherit;
     }
   }
 }
 
 .subtitle-compare {
   margin: -15px 0px 0px 0px;
 }
 
 // new entry in group_members
 .td-author-new-entry {
   background-color: rgba(red(@alert1), green(@alert1), blue(@alert1), 0.3);
 }
 
 .usergroup_member_remove {
     width: 16px;
     margin-bottom: 10px;
     padding: 0;
     color: black !important;
     cursor: pointer;
 }
 
 .reviewer_ac .ac-input {
+    width: 98%;
+    margin-bottom: 1em;
+}
+
+.observer_ac .ac-input {
+    width: 98%;
+    margin-bottom: 1em;
+}
+
+.rule-table {
     width: 100%;
-    margin-bottom: 1em;
+}
+
+.rule-table td {
+
+}
+
+.rule-table .td-role {
+  width: 100px
+}
+
+.rule-table .td-mandatory {
+  width: 100px
+}
+
+.rule-table .td-group-votes {
+  width: 150px
 }
 
 .compare_view_commits tr{
     height: 20px;
 }
 .compare_view_commits td {
     vertical-align: top;
     padding-top: 10px;
 }
 .compare_view_commits .author {
     margin-left: 5px;
 }
 
 .compare_view_commits {
   .color-a {
     color: @alert1;
   }
 
   .color-c {
     color: @color3;
   }
 
   .color-r {
     color: @color5;
   }
 
   .color-a-bg {
     background-color: @alert1;
   }
 
   .color-c-bg {
     background-color: @alert3;
   }
 
   .color-r-bg {
     background-color: @alert2;
   }
 
   .color-a-border {
     border: 1px solid @alert1;
   }
 
   .color-c-border {
     border: 1px solid @alert3;
   }
 
   .color-r-border {
     border: 1px solid @alert2;
   }
 
   .commit-change-indicator {
     width: 15px;
     height: 15px;
     position: relative;
     left: 15px;
   }
 
   .commit-change-content {
     text-align: center;
     vertical-align: middle;
     line-height: 15px;
   }
 }
 
 .compare_view_filepath {
     color: @grey1;
 }
 
 .show_more {
     display: inline-block;
     width: 0;
     height: 0;
     vertical-align: middle;
     content: "";
     border: 4px solid;
     border-right-color: transparent;
     border-bottom-color: transparent;
     border-left-color: transparent;
     font-size: 0;
 }
 
 .journal_more .show_more {
     display: inline;
 
     &:after {
         content: none;
     }
 }
 
 .compare_view_commits .collapse_commit:after {
     cursor: pointer;
     content: "\00A0\25B4";
     margin-left: -3px;
     font-size: 17px;
     color: @grey4;
 }
 
 .diff_links {
     margin-left: 8px;
 }
 
 #pull_request_overview {
   div.ancestor {
       margin: -33px 0;
   }
 }
 
 div.ancestor {
 
 }
 
 .cs_icon_td input[type="checkbox"] {
     display: none;
 }
 
 .cs_icon_td .expand_file_icon:after {
     cursor: pointer;
     content: "\00A0\25B6";
     font-size: 12px;
     color: @grey4;
 }
 
 .cs_icon_td .collapse_file_icon:after {
     cursor: pointer;
     content: "\00A0\25BC";
     font-size: 12px;
     color: @grey4;
 }
 
 /*new binary
 NEW_FILENODE = 1
 DEL_FILENODE = 2
 MOD_FILENODE = 3
 RENAMED_FILENODE = 4
 COPIED_FILENODE = 5
 CHMOD_FILENODE = 6
 BIN_FILENODE = 7
 */
 .cs_files_expand {
     font-size: @basefontsize + 5px;
     line-height: 1.8em;
     float: right;
 }
 
 .cs_files_expand span{
     color: @rcblue;
     cursor: pointer;
 }
 .cs_files {
     clear: both;
 	padding-bottom: @padding;
 
     .cur_cs {
         margin: 10px 2px;
         font-weight: bold;
     }
 
     .node {
         float: left;
     }
 
     .changes {
         float: right;
         color: white;
         font-size: @basefontsize - 4px;
         margin-top: 4px;
         opacity: 0.6;
         filter: Alpha(opacity=60); /* IE8 and earlier */
 
         .added {
             background-color: @alert1;
             float: left;
             text-align: center;
         }
 
         .deleted {
             background-color: @alert2;
             float: left;
             text-align: center;
         }
 
         .bin {
             background-color: @alert1;
             text-align: center;
         }
 
         /*new binary*/
         .bin.bin1 {
             background-color: @alert1;
             text-align: center;
         }
 
         /*deleted binary*/
         .bin.bin2 {
             background-color: @alert2;
             text-align: center;
         }
 
         /*mod binary*/
         .bin.bin3 {
             background-color: @grey2;
             text-align: center;
         }
 
         /*rename file*/
         .bin.bin4 {
             background-color: @alert4;
             text-align: center;
         }
 
         /*copied file*/
         .bin.bin5 {
             background-color: @alert4;
             text-align: center;
         }
 
         /*chmod file*/
         .bin.bin6 {
             background-color: @grey2;
             text-align: center;
         }
     }
 }
 
 .cs_files .cs_added, .cs_files .cs_A,
 .cs_files .cs_added, .cs_files .cs_M,
 .cs_files .cs_added, .cs_files .cs_D {
     height: 16px;
     padding-right: 10px;
     margin-top: 7px;
     text-align: left;
 }
 
 .cs_icon_td {
   min-width: 16px;
   width: 16px;
 }
 
 .pull-request-merge {
     border: 1px solid @grey5;
     padding: 10px 0px 20px;
     margin-top: 10px;
     margin-bottom: 20px;
 }
 
 .pull-request-merge-refresh {
   margin: 2px 7px;
   a {
     color: @grey3;
   }
 }
 
 .pull-request-merge ul {
     padding: 0px 0px;
 }
 
 .pull-request-merge li {
     list-style-type: none;
 }
 
 .pull-request-merge .pull-request-wrap {
     height: auto;
     padding: 0px 0px;
     text-align: right;
 }
 
 .pull-request-merge span {
     margin-right: 5px;
 }
 
 .pull-request-merge-actions {
     min-height: 30px;
     padding: 0px 0px;
 }
 
 .pull-request-merge-info {
   padding: 0px 5px 5px 0px;
 }
 
 .merge-status {
   margin-right: 5px;
 }
 
 .merge-message {
     font-size: 1.2em
 }
 
 .merge-message.success i,
 .merge-icon.success i {
     color:@alert1;
 }
 
 .merge-message.warning i,
 .merge-icon.warning i {
   color: @alert3;
 }
 
 .merge-message.error i,
 .merge-icon.error i  {
     color:@alert2;
 }
 
 .pr-versions {
     font-size: 1.1em;
     padding: 7.5px;
 
     table {
 
     }
 
     td {
       line-height: 15px;
     }
 
     .compare-radio-button {
       position: relative;
       top: -3px;
     }
 }
 
 
 #close_pull_request {
     margin-right: 0px;
 }
 
 .empty_data {
     color: @grey4;
 }
 
 #changeset_compare_view_content {
     clear: both;
     width: 100%;
     box-sizing: border-box;
     .border-radius(@border-radius);
 
     .help-block {
         margin: @padding 0;
         color: @text-color;
         &.pre-formatting {
             white-space: pre;
         }
     }
 
     .empty_data {
         margin: @padding 0;
     }
 
     .alert {
         margin-bottom: @space;
     }
 }
 
 .table_disp {
 	.status {
 		width: auto;
 	}
 }
 
 
 .creation_in_progress {
   color: @grey4
 }
 
 .status_box_menu {
     margin: 0;
 }
 
 .notification-table{
 	margin-bottom: @space;
 	display: table;
 	width: 100%;
 
 	.container{
 		display: table-row;
 
 		.notification-header{
 			border-bottom: @border-thickness solid @border-default-color;
 		}
 
 		.notification-subject{
 			display: table-cell;
 		}
 	}
 }
 
 // Notifications
 .notification-header{
 	display: table;
 	width: 100%;
 	padding: floor(@basefontsize/2) 0;
     line-height: 1em;
 
 	.desc, .delete-notifications, .read-notifications{
 		display: table-cell;
 		text-align: left;
 	}
 
 	.delete-notifications, .read-notifications{
 		width: 35px;
 		min-width: 35px; //fixes when only one button is displayed
 	}
 }
 
 .notification-body {
     .markdown-block,
 	.rst-block {
 		padding: @padding 0;
 	}
 
 	.notification-subject {
 		padding: @textmargin 0;
 		border-bottom: @border-thickness solid @border-default-color;
 	}
 }
 
 .notice-messages {
     .markdown-block,
 	.rst-block {
 		padding: 0;
 	}
 }
 
 .notifications_buttons{
 	float: right;
 }
 
 #notification-status{
   display: inline;
 }
 
 // Repositories
 
 #summary.fields{
 	display: table;
 
 	.field{
 		display: table-row;
 
 		.label-summary{
 			display: table-cell;
 			min-width: @label-summary-minwidth;
 			padding-top: @padding/2;
 			padding-bottom: @padding/2;
 			padding-right: @padding/2;
 		}
 
 		.input{
 			display: table-cell;
 			padding: @padding/2;
 
 			input{
 				min-width: 29em;
 				padding:  @padding/4;
 			}
 		}
 		.statistics, .downloads{
 			.disabled{
 				color: @grey4;
 			}
 		}
 	}
 }
 
 #summary{
 	width: 70%;
 }
 
 
 // Journal
 .journal.title {
 	h5 {
 		float: left;
 		margin: 0;
 		width: 70%;
 	}
 
 	ul {
 		float: right;
 		display: inline-block;
 		margin: 0;
 		width: 30%;
 		text-align: right;
 
 		li {
 			display: inline;
 			font-size: @journal-fontsize;
             line-height: 1em;
 
             list-style-type: none;
 		}
 	}
 }
 
 .filterexample {
     position: absolute;
     top: 95px;
     left: @contentpadding;
     color: @rcblue;
     font-size: 11px;
     font-family: @text-regular;
     cursor: help;
 
     &:hover {
         color: @rcdarkblue;
     }
 
     @media (max-width:768px) {
         position: relative;
         top: auto;
         left: auto;
         display: block;
     }
 }
 
 
 #journal{
 	margin-bottom: @space;
 
 	.journal_day{
 		margin-bottom: @textmargin/2;
 		padding-bottom: @textmargin/2;
 		font-size: @journal-fontsize;
 		border-bottom: @border-thickness solid @border-default-color;
 	}
 
 	.journal_container{
 		margin-bottom: @space;
 
 		.journal_user{
 			display: inline-block;
 		}
 		.journal_action_container{
 			display: block;
 			margin-top: @textmargin;
 
 			div{
 				display: inline;
 			}
 
 			div.journal_action_params{
 				display: block;
 			}
 
 			div.journal_repo:after{
 				content: "\A";
 				white-space: pre;
 			}
 
 			div.date{
 				display: block;
 				margin-bottom: @textmargin;
 			}
 		}
 	}
 }
 
 // Files
 .edit-file-title {
     font-size: 16px;
 
     .title-heading {
       padding: 2px;
     }
 }
 
 .edit-file-fieldset {
     margin: @sidebarpadding 0;
 
     .fieldset {
         .left-label {
             width: 13%;
         }
         .right-content {
             width: 87%;
             max-width: 100%;
         }
         .filename-label {
             margin-top: 13px;
         }
         .commit-message-label {
             margin-top: 4px;
         }
         .file-upload-input {
             input {
                 display: none;
             }
           margin-top: 10px;
         }
         .file-upload-label {
           margin-top: 10px;
         }
         p {
             margin-top: 5px;
         }
 
     }
     .custom-path-link {
         margin-left: 5px;
     }
     #commit {
         resize: vertical;
     }
 }
 
 .delete-file-preview {
     max-height: 250px;
 }
 
 .new-file,
 #filter_activate,
 #filter_deactivate {
     float: right;
     margin: 0 0 0 10px;
 }
 
 .file-upload-transaction-wrapper {
     margin-top: 57px;
     clear: both;
 }
 
 .file-upload-transaction-wrapper .error {
     color: @color5;
 }
 
 .file-upload-transaction {
     min-height: 200px;
     padding: 54px;
     border: 1px solid @grey5;
     text-align: center;
     clear: both;
 }
 
 .file-upload-transaction i {
     font-size: 48px
 }
 
 h3.files_location{
     line-height: 2.4em;
 }
 
 .browser-nav {
     width: 100%;
 	display: table;
     margin-bottom: 20px;
 
 	.info_box {
         float: left;
 		display: inline-table;
 		height: 2.5em;
 
         .browser-cur-rev, .info_box_elem {
 			display: table-cell;
 			vertical-align: middle;
 		}
 
         .drop-menu {
             margin: 0 10px;
         }
 
 		.info_box_elem {
 			border-top: @border-thickness solid @grey5;
 			border-bottom: @border-thickness solid @grey5;
             box-shadow: @button-shadow;
 
             #at_rev, a {
                 padding: 0.6em 0.4em;
                 margin: 0;
                 .box-shadow(none);
                 border: 0;
                 height: 12px;
                 color: @grey2;
             }
 
             input#at_rev {
                 max-width: 50px;
                 text-align: center;
             }
 
 			&.previous {
 				border: @border-thickness solid @grey5;
                 border-top-left-radius: @border-radius;
                 border-bottom-left-radius: @border-radius;
 
                 &:hover {
                     border-color: @grey4;
                 }
 
                 .disabled {
                   color: @grey5;
                   cursor: not-allowed;
                   opacity: 0.5;
                 }
 			}
 
 			&.next {
 				border: @border-thickness solid @grey5;
                 border-top-right-radius: @border-radius;
                 border-bottom-right-radius: @border-radius;
 
                 &:hover {
                     border-color: @grey4;
                 }
 
                 .disabled {
                   color: @grey5;
                   cursor: not-allowed;
                   opacity: 0.5;
                 }
 			}
 		}
 
 		.browser-cur-rev {
 
 			span{
                 margin: 0;
 				color: @rcblue;
                 height: 12px;
                 display: inline-block;
                 padding:  0.7em 1em ;
                 border: @border-thickness solid @rcblue;
                 margin-right: @padding;
 			}
 		}
 
 	}
 
     .select-index-number {
         margin: 0 0 0 20px;
         color: @grey3;
     }
 
 	.search_activate {
 		display: table-cell;
 		vertical-align: middle;
 
 		input, label{
 			margin: 0;
 			padding: 0;
 		}
 
 		input{
 			margin-left: @textmargin;
 		}
 
 	}
 }
 
 .browser-cur-rev{
 	margin-bottom: @textmargin;
 }
 
 #node_filter_box_loading{
 	.info_text;
 }
 
 .browser-search {
 	margin: -25px 0px 5px 0px;
 }
 
 .files-quick-filter {
   float: right;
   width: 180px;
   position: relative;
 }
 
 .files-filter-box {
   display: flex;
   padding: 0px;
   border-radius: 3px;
   margin-bottom: 0;
 
   a {
     border: none !important;
   }
 
   li {
     list-style-type: none
   }
 }
 
 .files-filter-box-path {
   line-height: 33px;
   padding: 0;
   width: 20px;
   position: absolute;
   z-index: 11;
   left: 5px;
 }
 
 .files-filter-box-input {
   margin-right: 0;
 
   input {
     border: 1px solid @white;
     padding-left: 25px;
     width: 145px;
 
     &:hover {
         border-color: @grey6;
     }
 
     &:focus {
         border-color: @grey5;
     }
   }
 }
 
 .browser-result{
 	td a{
 		margin-left: 0.5em;
 		display: inline-block;
 
 		em {
           font-weight: @text-bold-weight;
           font-family: @text-bold;
         }
 	}
 }
 
 .browser-highlight{
 	background-color: @grey5-alpha;
 }
 
 
 .edit-file-fieldset #location,
 .edit-file-fieldset #filename {
   display: flex;
   width: -moz-available; /* WebKit-based browsers will ignore this. */
   width: -webkit-fill-available; /* Mozilla-based browsers will ignore this. */
   width: fill-available;
   border: 0;
 }
 
 .path-items {
   display: flex;
   padding: 0;
   border: 1px solid #eeeeee;
   width: 100%;
   float: left;
 
   .breadcrumb-path {
     line-height: 30px;
     padding: 0 4px;
     white-space: nowrap;
   }
 
   .upload-form {
     margin-top: 46px;
   }
 
   .location-path {
     width: -moz-available; /* WebKit-based browsers will ignore this. */
     width: -webkit-fill-available; /* Mozilla-based browsers will ignore this. */
     width: fill-available;
 
     .file-name-input {
       padding: 0.5em 0;
     }
 
   }
 
   ul {
     display: flex;
     margin: 0;
     padding: 0;
     width: 100%;
   }
 
   li {
     list-style-type: none;
   }
 
 }
 
 .editor-items {
   height: 40px;
   margin: 10px 0 -17px 10px;
 
   .editor-action {
     cursor: pointer;
   }
 
   .editor-action.active {
     border-bottom: 2px solid #5C5C5C;
   }
 
   li {
     list-style-type: none;
   }
 }
 
 .edit-file-fieldset .message textarea {
   border: 1px solid #eeeeee;
 }
 
 #files_data .codeblock {
   background-color: #F5F5F5;
 }
 
 #editor_preview {
   background: white;
 }
 
 .show-editor {
   padding: 10px;
   background-color: white;
 
 }
 
 .show-preview {
   padding: 10px;
   background-color: white;
   border-left: 1px solid #eeeeee;
 }
 // quick filter
 .grid-quick-filter {
   float: right;
     position: relative;
 }
 
 .grid-filter-box {
   display: flex;
   padding: 0px;
   border-radius: 3px;
   margin-bottom: 0;
 
   a {
     border: none !important;
   }
 
   li {
     list-style-type: none
   }
 }
 
 .grid-filter-box-icon {
   line-height: 33px;
   padding: 0;
   width: 20px;
   position: absolute;
   z-index: 11;
   left: 5px;
 }
 
 .grid-filter-box-input {
   margin-right: 0;
 
   input {
     border: 1px solid @white;
     padding-left: 25px;
     width: 145px;
 
     &:hover {
         border-color: @grey6;
     }
 
     &:focus {
         border-color: @grey5;
     }
   }
 }
 
 
 
 // Search
 
 .search-form{
     #q {
         width: @search-form-width;
     }
 	.fields{
 		margin: 0 0 @space;
 	}
 
 	label{
 		display: inline-block;
 		margin-right: @textmargin;
 		padding-top: 0.25em;
 	}
 
 
 	.results{
 		clear: both;
 		margin: 0 0 @padding;
 	}
 
     .search-tags {
       padding: 5px 0;
     }
 }
 
 div.search-feedback-items {
 	display: inline-block;
 }
 
 div.search-code-body {
     background-color: #ffffff; padding: 5px 0 5px 10px;
     pre {
         .match { background-color: #faffa6;}
         .break { display: block; width: 100%; background-color: #DDE7EF; color: #747474; }
     }
 }
 
 .expand_commit.search {
     .show_more.open {
         height: auto;
         max-height: none;
     }
 }
 
 .search-results {
 
     h2 {
         margin-bottom: 0;
     }
     .codeblock {
         border: none;
         background: transparent;
     }
 
     .codeblock-header {
         border: none;
         background: transparent;
     }
 
     .code-body {
         border: @border-thickness solid @grey6;
         .border-radius(@border-radius);
     }
 
     .td-commit {
         &:extend(pre);
         border-bottom: @border-thickness solid @border-default-color;
     }
 
     .message {
         height: auto;
         max-width: 350px;
         white-space: normal;
         text-overflow: initial;
         overflow: visible;
 
         .match { background-color: #faffa6;}
         .break { background-color: #DDE7EF; width: 100%; color: #747474; display: block; }
     }
 
     .path {
       border-bottom: none !important;
       border-left: 1px solid @grey6 !important;
       border-right: 1px solid @grey6 !important;
     }
 }
 
 table.rctable td.td-search-results div {
     max-width: 100%;
 }
 
 #tip-box, .tip-box{
 	padding: @menupadding/2;
 	display: block;
 	border: @border-thickness solid @border-highlight-color;
 	.border-radius(@border-radius);
 	background-color: white;
     z-index: 99;
     white-space: pre-wrap;
 }
 
 #linktt {
     width: 79px;
 }
 
 #help_kb .modal-content{
 	max-width: 800px;
 	margin: 10% auto;
 
 	table{
 		td,th{
 			border-bottom: none;
 			line-height: 2.5em;
 		}
 		th{
 			padding-bottom: @textmargin/2;
 		}
 		td.keys{
 			text-align: center;
 		}
 	}
 
 	.block-left{
 		width: 45%;
 		margin-right: 5%;
 	}
 	.modal-footer{
 		clear: both;
 	}
 	.key.tag{
 		padding: 0.5em;
 		background-color: @rcblue;
 		color: white;
 		border-color: @rcblue;
 		.box-shadow(none);
 	}
 }
 
 
 
 //--- IMPORTS FOR REFACTORED STYLES ------------------//
 
 @import 'statistics-graph';
 @import 'tables';
 @import 'forms';
 @import 'diff';
 @import 'summary';
 @import 'navigation';
 
 //--- SHOW/HIDE SECTIONS --//
 
 .btn-collapse {
     float: right;
     text-align: right;
     font-family: @text-light;
     font-size: @basefontsize;
     cursor: pointer;
     border: none;
     color: @rcblue;
 }
 
 table.rctable,
 table.dataTable {
     .btn-collapse {
         float: right;
         text-align: right;
     }
 }
 
 table.rctable {
   &.permissions {
 
     th.td-owner {
       padding: 0;
     }
 
     th {
       font-weight: normal;
       padding: 0 5px;
     }
 
   }
 }
 
 
 // TODO: johbo: Fix for IE10, this avoids that we see a border
 // and padding around checkboxes and radio boxes. Move to the right place,
 // or better: Remove this once we did the form refactoring.
 input[type=checkbox],
 input[type=radio] {
     padding: 0;
     border: none;
 }
 
 .toggle-ajax-spinner{
   height: 16px;
   width: 16px;
 }
 
 
 .markup-form .clearfix {
     .border-radius(@border-radius);
     margin: 0px;
 }
 
 .markup-form-area {
     padding: 8px 12px;
     border: 1px solid @grey4;
     .border-radius(@border-radius);
 }
 
 .markup-form-area-header .nav-links {
     display: flex;
     flex-flow: row wrap;
     -webkit-flex-flow: row wrap;
     width: 100%;
 }
 
 .markup-form-area-footer {
     display: flex;
 }
 
 .markup-form-area-footer .toolbar {
 
 }
 
 // markup Form
 div.markup-form {
     margin-top: 20px;
 }
 
 .markup-form strong {
     display: block;
     margin-bottom: 15px;
 }
 
 .markup-form textarea {
     width: 100%;
     height: 100px;
     font-family: @text-monospace;
 }
 
 form.markup-form {
     margin-top: 10px;
     margin-left: 10px;
 }
 
 .markup-form .comment-block-ta,
 .markup-form .preview-box {
     .border-radius(@border-radius);
     .box-sizing(border-box);
     background-color: white;
 }
 
 .markup-form .preview-box.unloaded {
     height: 50px;
     text-align: center;
     padding: 20px;
     background-color: white;
 }
 
 
 .dropzone-wrapper {
   border: 1px solid @grey5;
   padding: 20px;
 }
 
 .dropzone,
 .dropzone-pure {
   border: 2px dashed @grey5;
   border-radius: 5px;
   background: white;
   min-height: 200px;
   padding: 54px;
 
   .dz-message {
     font-weight: 700;
     text-align: center;
     margin: 2em 0;
   }
 
 }
 
 .dz-preview {
   margin: 10px 0 !important;
   position: relative;
   vertical-align: top;
   padding: 10px;
   border-bottom: 1px solid @grey5;
 }
 
 .dz-filename {
   font-weight: 700;
   float: left;
 }
 
 .dz-sending {
   float: right;
 }
 
 .dz-response {
   clear: both
 }
 
 .dz-filename-size {
   float: right
 }
 
 .dz-error-message {
   color: @alert2;
   padding-top: 10px;
   clear: both;
 }
 
 
 .user-hovercard {
   padding: 5px;
 }
 
 .user-hovercard-icon {
   display: inline;
   padding: 0;
   box-sizing: content-box;
   border-radius: 50%;
   float: left;
 }
 
 .user-hovercard-name {
   float: right;
   vertical-align: top;
   padding-left: 10px;
   min-width: 150px;
 }
 
 .user-hovercard-bio {
   clear: both;
   padding-top: 10px;
 }
 
 .user-hovercard-header {
   clear: both;
   min-height: 10px;
 }
 
 .user-hovercard-footer {
   clear: both;
   min-height: 10px;
 }
 
 .user-group-hovercard {
   padding: 5px;
 }
 
 .user-group-hovercard-icon {
   display: inline;
   padding: 0;
   box-sizing: content-box;
   border-radius: 50%;
   float: left;
 }
 
 .user-group-hovercard-name {
   float: left;
   vertical-align: top;
   padding-left: 10px;
   min-width: 150px;
 }
 
 .user-group-hovercard-icon i {
   border: 1px solid @grey4;
   border-radius: 4px;
 }
 
 .user-group-hovercard-bio {
   clear: both;
   padding-top: 10px;
   line-height: 1.0em;
 }
 
 .user-group-hovercard-header {
   clear: both;
   min-height: 10px;
 }
 
 .user-group-hovercard-footer {
   clear: both;
   min-height: 10px;
 }
 
 .pr-hovercard-header {
   clear: both;
   display: block;
   line-height: 20px;
 }
 
 .pr-hovercard-user {
   display: flex;
   align-items: center;
   padding-left: 5px;
 }
 
 .pr-hovercard-title {
   padding-top: 5px;
 }
 
 .action-divider {
   opacity: 0.5;
 }
 
 .details-inline-block {
   display: inline-block;
   position: relative;
 }
 
 .details-inline-block summary {
   list-style: none;
 }
 
 details:not([open]) > :not(summary) {
   display: none !important;
 }
 
 .details-reset > summary {
   list-style: none;
 }
 
 .details-reset > summary::-webkit-details-marker {
   display: none;
 }
 
 .details-dropdown {
   position: absolute;
   top: 100%;
   width: 185px;
   list-style: none;
   background-color: #fff;
   background-clip: padding-box;
   border: 1px solid @grey5;
   box-shadow: 0 8px 24px rgba(149, 157, 165, .2);
   left: -150px;
   text-align: left;
   z-index: 90;
 }
 
 .dropdown-divider {
   display: block;
   height: 0;
   margin: 8px 0;
   border-top: 1px solid @grey5;
 }
 
 .dropdown-item {
   display: block;
   padding: 4px 8px 4px 16px;
   overflow: hidden;
   text-overflow: ellipsis;
   white-space: nowrap;
   font-weight: normal;
 }
 
 .right-sidebar {
   position: fixed;
   top: 0px;
   bottom: 0;
   right: 0;
 
   background: #fafafa;
   z-index: 50;
 }
 
 .right-sidebar {
   border-left: 1px solid @grey5;
 }
 
 .right-sidebar.right-sidebar-expanded {
   width: 300px;
   overflow: scroll;
 }
 
 .right-sidebar.right-sidebar-collapsed {
   width: 40px;
   padding: 0;
   display: block;
   overflow: hidden;
 }
 
 .sidenav {
   float: right;
   will-change: min-height;
   background: #fafafa;
   width: 100%;
 }
 
 .sidebar-toggle {
   height: 30px;
   text-align: center;
   margin: 15px 0px 0 0;
 }
 
 .sidebar-toggle a {
 
 }
 
 .sidebar-content {
   margin-left: 15px;
   margin-right: 15px;
 }
 
 .sidebar-heading {
   font-size: 1.2em;
   font-weight: 700;
   margin-top: 10px;
 }
 
 .sidebar-element {
   margin-top: 20px;
 }
 
 .right-sidebar-collapsed-state {
   display: flex;
   flex-direction: column;
   justify-content: center;
   align-items: center;
   padding: 0 10px;
   cursor: pointer;
   font-size: 1.3em;
   margin: 0 -15px;
 }
 
 .right-sidebar-collapsed-state:hover {
   background-color: @grey5;
 }
 
 .old-comments-marker {
   text-align: left;
 }
 
 .old-comments-marker td {
   padding-top: 15px;
   border-bottom: 1px solid @grey5;
 }

rhodecode/public/js/src/rhodecode/pullrequests.js

@@ -1,890 +1,1175 b''
 // # Copyright (C) 2010-2020 RhodeCode GmbH
 // #
 // # This program is free software: you can redistribute it and/or modify
 // # it under the terms of the GNU Affero General Public License, version 3
 // # (only), as published by the Free Software Foundation.
 // #
 // # 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 Affero General Public License
 // # along with this program.  If not, see <http://www.gnu.org/licenses/>.
 // #
 // # This program is dual-licensed. If you wish to learn more about the
 // # RhodeCode Enterprise Edition, including its added features, Support services,
 // # and proprietary license terms, please see https://rhodecode.com/licenses/
 
 
 var prButtonLockChecks = {
   'compare': false,
   'reviewers': false
 };
 
 /**
  * lock button until all checks and loads are made. E.g reviewer calculation
  * should prevent from submitting a PR
  * @param lockEnabled
  * @param msg
  * @param scope
  */
 var prButtonLock = function(lockEnabled, msg, scope) {
       scope = scope || 'all';
       if (scope == 'all'){
           prButtonLockChecks['compare'] = !lockEnabled;
           prButtonLockChecks['reviewers'] = !lockEnabled;
       } else if (scope == 'compare') {
           prButtonLockChecks['compare'] = !lockEnabled;
       } else if (scope == 'reviewers'){
           prButtonLockChecks['reviewers'] = !lockEnabled;
       }
       var checksMeet = prButtonLockChecks.compare && prButtonLockChecks.reviewers;
       if (lockEnabled) {
           $('#pr_submit').attr('disabled', 'disabled');
       }
       else if (checksMeet) {
           $('#pr_submit').removeAttr('disabled');
       }
 
       if (msg) {
           $('#pr_open_message').html(msg);
       }
 };
 
 
 /**
 Generate Title and Description for a PullRequest.
 In case of 1 commits, the title and description is that one commit
 in case of multiple commits, we iterate on them with max N number of commits,
 and build description in a form
 - commitN
 - commitN+1
 ...
 
 Title is then constructed from branch names, or other references,
 replacing '-' and '_' into spaces
 
 * @param sourceRef
 * @param elements
 * @param limit
 * @returns {*[]}
 */
 var getTitleAndDescription = function(sourceRefType, sourceRef, elements, limit) {
   var title = '';
   var desc = '';
 
   $.each($(elements).get().reverse().slice(0, limit), function(idx, value) {
       var rawMessage = value['message'];
       desc += '- ' + rawMessage.split('\n')[0].replace(/\n+$/, "") + '\n';
   });
   // only 1 commit, use commit message as title
   if (elements.length === 1) {
       var rawMessage = elements[0]['message'];
       title = rawMessage.split('\n')[0];
   }
   else {
       // use reference name
       var normalizedRef = sourceRef.replace(/-/g, ' ').replace(/_/g, ' ').capitalizeFirstLetter()
       var refType = sourceRefType;
       title = 'Changes from {0}: {1}'.format(refType, normalizedRef);
   }
 
   return [title, desc]
 };
 
 
-ReviewersController = function () {
+window.ReviewersController = function () {
     var self = this;
+    this.$loadingIndicator = $('.calculate-reviewers');
     this.$reviewRulesContainer = $('#review_rules');
     this.$rulesList = this.$reviewRulesContainer.find('.pr-reviewer-rules');
     this.$userRule = $('.pr-user-rule-container');
-    this.forbidReviewUsers = undefined;
     this.$reviewMembers = $('#review_members');
+    this.$observerMembers = $('#observer_members');
+
     this.currentRequest = null;
     this.diffData = null;
     this.enabledRules = [];
+    // sync with db.py entries
+    this.ROLE_REVIEWER = 'reviewer';
+    this.ROLE_OBSERVER = 'observer'
 
     //dummy handler, we might register our own later
-    this.diffDataHandler = function(data){};
+    this.diffDataHandler = function (data) {};
 
-    this.defaultForbidReviewUsers = function () {
+    this.defaultForbidUsers = function () {
         return [
             {
                 'username': 'default',
                 'user_id': templateContext.default_user.user_id
             }
         ];
     };
 
+    // init default forbidden users
+    this.forbidUsers = this.defaultForbidUsers();
+
     this.hideReviewRules = function () {
         self.$reviewRulesContainer.hide();
         $(self.$userRule.selector).hide();
     };
 
     this.showReviewRules = function () {
         self.$reviewRulesContainer.show();
         $(self.$userRule.selector).show();
     };
 
     this.addRule = function (ruleText) {
         self.showReviewRules();
         self.enabledRules.push(ruleText);
         return '<div>- {0}</div>'.format(ruleText)
     };
 
+    this.increaseCounter = function(role) {
+        if (role === self.ROLE_REVIEWER) {
+            var $elem = $('#reviewers-cnt')
+            var cnt = parseInt($elem.data('count') || 0)
+            cnt +=1
+            $elem.html(cnt);
+            $elem.data('count', cnt);
+        }
+        else if (role === self.ROLE_OBSERVER) {
+            var $elem = $('#observers-cnt');
+            var cnt = parseInt($elem.data('count') || 0)
+            cnt +=1
+            $elem.html(cnt);
+            $elem.data('count', cnt);
+        }
+    }
+
+    this.resetCounter = function () {
+        var $elem = $('#reviewers-cnt');
+
+        $elem.data('count', 0);
+        $elem.html(0);
+
+        var $elem = $('#observers-cnt');
+
+        $elem.data('count', 0);
+        $elem.html(0);
+    }
+
     this.loadReviewRules = function (data) {
         self.diffData = data;
 
         // reset forbidden Users
-        this.forbidReviewUsers = self.defaultForbidReviewUsers();
+        this.forbidUsers = self.defaultForbidUsers();
 
         // reset state of review rules
         self.$rulesList.html('');
 
         if (!data || data.rules === undefined || $.isEmptyObject(data.rules)) {
             // default rule, case for older repo that don't have any rules stored
             self.$rulesList.append(
                 self.addRule(
                     _gettext('All reviewers must vote.'))
             );
-            return self.forbidReviewUsers
+            return self.forbidUsers
         }
 
         if (data.rules.voting !== undefined) {
             if (data.rules.voting < 0) {
                 self.$rulesList.append(
                     self.addRule(
                         _gettext('All individual reviewers must vote.'))
                 )
             } else if (data.rules.voting === 1) {
                 self.$rulesList.append(
                     self.addRule(
                         _gettext('At least {0} reviewer must vote.').format(data.rules.voting))
                 )
 
             } else {
                 self.$rulesList.append(
                     self.addRule(
                         _gettext('At least {0} reviewers must vote.').format(data.rules.voting))
                 )
             }
         }
 
         if (data.rules.voting_groups !== undefined) {
             $.each(data.rules.voting_groups, function (index, rule_data) {
                 self.$rulesList.append(
                     self.addRule(rule_data.text)
                 )
             });
         }
 
         if (data.rules.use_code_authors_for_review) {
             self.$rulesList.append(
                 self.addRule(
                     _gettext('Reviewers picked from source code changes.'))
             )
         }
 
         if (data.rules.forbid_adding_reviewers) {
             $('#add_reviewer_input').remove();
             self.$rulesList.append(
                 self.addRule(
                     _gettext('Adding new reviewers is forbidden.'))
             )
         }
 
         if (data.rules.forbid_author_to_review) {
-            self.forbidReviewUsers.push(data.rules_data.pr_author);
+            self.forbidUsers.push(data.rules_data.pr_author);
             self.$rulesList.append(
                 self.addRule(
                     _gettext('Author is not allowed to be a reviewer.'))
             )
         }
 
         if (data.rules.forbid_commit_author_to_review) {
 
             if (data.rules_data.forbidden_users) {
                 $.each(data.rules_data.forbidden_users, function (index, member_data) {
-                    self.forbidReviewUsers.push(member_data)
+                    self.forbidUsers.push(member_data)
                 });
-
             }
 
             self.$rulesList.append(
                 self.addRule(
                     _gettext('Commit Authors are not allowed to be a reviewer.'))
             )
         }
 
         // we don't have any rules set, so we inform users about it
         if (self.enabledRules.length === 0) {
             self.addRule(
                 _gettext('No review rules set.'))
         }
 
-        return self.forbidReviewUsers
+        return self.forbidUsers
     };
 
+    this.emptyTables = function () {
+        self.emptyReviewersTable();
+        self.emptyObserversTable();
+
+        // Also reset counters.
+        self.resetCounter();
+    }
+
+    this.emptyReviewersTable = function (withText) {
+        self.$reviewMembers.empty();
+        if (withText !== undefined) {
+            self.$reviewMembers.html(withText)
+        }
+    };
+
+    this.emptyObserversTable = function (withText) {
+        self.$observerMembers.empty();
+        if (withText !== undefined) {
+            self.$observerMembers.html(withText)
+        }
+    }
+
     this.loadDefaultReviewers = function (sourceRepo, sourceRef, targetRepo, targetRef) {
 
         if (self.currentRequest) {
             // make sure we cleanup old running requests before triggering this again
             self.currentRequest.abort();
         }
 
-        $('.calculate-reviewers').show();
-        // reset reviewer members
-        self.$reviewMembers.empty();
+        self.$loadingIndicator.show();
+
+        // reset reviewer/observe members
+        self.emptyTables();
 
         prButtonLock(true, null, 'reviewers');
         $('#user').hide(); // hide user autocomplete before load
+        $('#observer').hide(); //hide observer autocomplete before load
 
         // lock PR button, so we cannot send PR before it's calculated
         prButtonLock(true, _gettext('Loading diff ...'), 'compare');
 
         if (sourceRef.length !== 3 || targetRef.length !== 3) {
             // don't load defaults in case we're missing some refs...
-            $('.calculate-reviewers').hide();
+            self.$loadingIndicator.hide();
             return
         }
 
         var url = pyroutes.url('repo_default_reviewers_data',
             {
                 'repo_name': templateContext.repo_name,
                 'source_repo': sourceRepo,
                 'source_ref': sourceRef[2],
                 'target_repo': targetRepo,
                 'target_ref': targetRef[2]
             });
 
         self.currentRequest = $.ajax({
             url: url,
             headers: {'X-PARTIAL-XHR': true},
             type: 'GET',
             success: function (data) {
 
                 self.currentRequest = null;
 
                 // review rules
                 self.loadReviewRules(data);
                 self.handleDiffData(data["diff_info"]);
 
                 for (var i = 0; i < data.reviewers.length; i++) {
                     var reviewer = data.reviewers[i];
-                    self.addReviewMember(reviewer, reviewer.reasons, reviewer.mandatory);
+                    // load reviewer rules from the repo data
+                    self.addMember(reviewer, reviewer.reasons, reviewer.mandatory, reviewer.role);
                 }
-                $('.calculate-reviewers').hide();
+
+
+                self.$loadingIndicator.hide();
                 prButtonLock(false, null, 'reviewers');
-                $('#user').show(); // show user autocomplete after load
+
+                $('#user').show(); // show user autocomplete before load
+                $('#observer').show(); // show observer autocomplete before load
 
                 var commitElements = data["diff_info"]['commits'];
 
                 if (commitElements.length === 0) {
                     var noCommitsMsg = '<span class="alert-text-warning">{0}</span>'.format(
                         _gettext('There are no commits to merge.'));
                     prButtonLock(true, noCommitsMsg, 'all');
 
                 } else {
                     // un-lock PR button, so we cannot send PR before it's calculated
                     prButtonLock(false, null, 'compare');
                 }
 
             },
             error: function (jqXHR, textStatus, errorThrown) {
-                var prefix = "Loading diff and reviewers failed\n"
+                var prefix = "Loading diff and reviewers/observers failed\n"
                 var message = formatErrorMessage(jqXHR, textStatus, errorThrown, prefix);
                 ajaxErrorSwal(message);
             }
         });
 
     };
 
     // check those, refactor
-    this.removeReviewMember = function (reviewer_id, mark_delete) {
+    this.removeMember = function (reviewer_id, mark_delete) {
         var reviewer = $('#reviewer_{0}'.format(reviewer_id));
 
         if (typeof (mark_delete) === undefined) {
             mark_delete = false;
         }
 
         if (mark_delete === true) {
             if (reviewer) {
                 // now delete the input
                 $('#reviewer_{0} input'.format(reviewer_id)).remove();
+                $('#reviewer_{0}_rules input'.format(reviewer_id)).remove();
                 // mark as to-delete
                 var obj = $('#reviewer_{0}_name'.format(reviewer_id));
                 obj.addClass('to-delete');
                 obj.css({"text-decoration": "line-through", "opacity": 0.5});
             }
         } else {
             $('#reviewer_{0}'.format(reviewer_id)).remove();
         }
     };
 
-    this.reviewMemberEntry = function () {
+    this.addMember = function (reviewer_obj, reasons, mandatory, role) {
 
-    };
-
-    this.addReviewMember = function (reviewer_obj, reasons, mandatory) {
         var id = reviewer_obj.user_id;
         var username = reviewer_obj.username;
 
-        var reasons = reasons || [];
-        var mandatory = mandatory || false;
+        reasons = reasons || [];
+        mandatory = mandatory || false;
+        role = role || self.ROLE_REVIEWER
 
-        // register IDS to check if we don't have this ID already in
+        // register current set IDS to check if we don't have this ID already in
+        // and prevent duplicates
         var currentIds = [];
 
-        $.each(self.$reviewMembers.find('.reviewer_entry'), function (index, value) {
+        $.each($('.reviewer_entry'), function (index, value) {
             currentIds.push($(value).data('reviewerUserId'))
         })
 
         var userAllowedReview = function (userId) {
             var allowed = true;
-            $.each(self.forbidReviewUsers, function (index, member_data) {
+            $.each(self.forbidUsers, function (index, member_data) {
                 if (parseInt(userId) === member_data['user_id']) {
                     allowed = false;
                     return false // breaks the loop
                 }
             });
             return allowed
         };
 
         var userAllowed = userAllowedReview(id);
+
         if (!userAllowed) {
             alert(_gettext('User `{0}` not allowed to be a reviewer').format(username));
         } else {
             // only add if it's not there
             var alreadyReviewer = currentIds.indexOf(id) != -1;
 
             if (alreadyReviewer) {
-                alert(_gettext('User `{0}` already in reviewers').format(username));
+                alert(_gettext('User `{0}` already in reviewers/observers').format(username));
             } else {
+
                 var reviewerEntry = renderTemplate('reviewMemberEntry', {
                     'member': reviewer_obj,
                     'mandatory': mandatory,
+                    'role': role,
                     'reasons': reasons,
                     'allowed_to_update': true,
                     'review_status': 'not_reviewed',
                     'review_status_label': _gettext('Not Reviewed'),
                     'user_group': reviewer_obj.user_group,
                     'create': true,
                     'rule_show': true,
                 })
-                $(self.$reviewMembers.selector).append(reviewerEntry);
+
+                if (role === self.ROLE_REVIEWER) {
+                    $(self.$reviewMembers.selector).append(reviewerEntry);
+                    self.increaseCounter(self.ROLE_REVIEWER);
+                    $('#reviewer-empty-msg').remove()
+                }
+                else if (role === self.ROLE_OBSERVER) {
+                    $(self.$observerMembers.selector).append(reviewerEntry);
+                    self.increaseCounter(self.ROLE_OBSERVER);
+                    $('#observer-empty-msg').remove();
+                }
+
                 tooltipActivate();
             }
         }
 
     };
 
-    this.updateReviewers = function (repo_name, pull_request_id) {
-        var postData = $('#reviewers input').serialize();
-        _updatePullRequest(repo_name, pull_request_id, postData);
+    this.updateReviewers = function (repo_name, pull_request_id, role) {
+        if (role === 'reviewer') {
+            var postData = $('#reviewers input').serialize();
+            _updatePullRequest(repo_name, pull_request_id, postData);
+        } else if (role === 'observer') {
+            var postData = $('#observers input').serialize();
+            _updatePullRequest(repo_name, pull_request_id, postData);
+        }
     };
 
     this.handleDiffData = function (data) {
         self.diffDataHandler(data)
     }
 };
 
 
 var _updatePullRequest = function(repo_name, pull_request_id, postData) {
     var url = pyroutes.url(
         'pullrequest_update',
         {"repo_name": repo_name, "pull_request_id": pull_request_id});
     if (typeof postData === 'string' ) {
         postData += '&csrf_token=' + CSRF_TOKEN;
     } else {
         postData.csrf_token = CSRF_TOKEN;
     }
 
     var success = function(o) {
         var redirectUrl = o['redirect_url'];
         if (redirectUrl !== undefined && redirectUrl !== null && redirectUrl !== '') {
             window.location = redirectUrl;
         } else {
             window.location.reload();
         }
     };
 
     ajaxPOST(url, postData, success);
 };
 
 /**
  * PULL REQUEST update commits
  */
 var updateCommits = function(repo_name, pull_request_id, force) {
     var postData = {
         'update_commits': true
     };
     if (force !== undefined && force === true) {
         postData['force_refresh'] = true
     }
     _updatePullRequest(repo_name, pull_request_id, postData);
 };
 
 
 /**
  * PULL REQUEST edit info
  */
 var editPullRequest = function(repo_name, pull_request_id, title, description, renderer) {
     var url = pyroutes.url(
         'pullrequest_update',
         {"repo_name": repo_name, "pull_request_id": pull_request_id});
 
     var postData = {
         'title': title,
         'description': description,
         'description_renderer': renderer,
         'edit_pull_request': true,
         'csrf_token': CSRF_TOKEN
     };
     var success = function(o) {
         window.location.reload();
     };
     ajaxPOST(url, postData, success);
 };
 
 
 /**
- * Reviewer autocomplete
+ * autocomplete handler for reviewers/observers
  */
-var ReviewerAutoComplete = function(inputId) {
-  $(inputId).autocomplete({
-    serviceUrl: pyroutes.url('user_autocomplete_data'),
-    minChars:2,
-    maxHeight:400,
-    deferRequestBy: 300, //miliseconds
-    showNoSuggestionNotice: true,
-    tabDisabled: true,
-    autoSelectFirst: true,
-    params: { user_id: templateContext.rhodecode_user.user_id, user_groups:true, user_groups_expand:true, skip_default_user:true },
-    formatResult: autocompleteFormatResult,
-    lookupFilter: autocompleteFilterResult,
-    onSelect: function(element, data) {
+var autoCompleteHandler = function (inputId, controller, role) {
+
+    return function (element, data) {
         var mandatory = false;
-        var reasons = [_gettext('added manually by "{0}"').format(templateContext.rhodecode_user.username)];
+        var reasons = [_gettext('added manually by "{0}"').format(
+            templateContext.rhodecode_user.username)];
 
         // add whole user groups
         if (data.value_type == 'user_group') {
             reasons.push(_gettext('member of "{0}"').format(data.value_display));
 
-            $.each(data.members, function(index, member_data) {
+            $.each(data.members, function (index, member_data) {
                 var reviewer = member_data;
                 reviewer['user_id'] = member_data['id'];
                 reviewer['gravatar_link'] = member_data['icon_link'];
                 reviewer['user_link'] = member_data['profile_link'];
                 reviewer['rules'] = [];
-                reviewersController.addReviewMember(reviewer, reasons, mandatory);
+                controller.addMember(reviewer, reasons, mandatory, role);
             })
         }
         // add single user
         else {
             var reviewer = data;
             reviewer['user_id'] = data['id'];
             reviewer['gravatar_link'] = data['icon_link'];
             reviewer['user_link'] = data['profile_link'];
             reviewer['rules'] = [];
-            reviewersController.addReviewMember(reviewer, reasons, mandatory);
+            controller.addMember(reviewer, reasons, mandatory, role);
         }
 
-      $(inputId).val('');
+        $(inputId).val('');
     }
-  });
+}
+
+/**
+ * Reviewer autocomplete
+ */
+var ReviewerAutoComplete = function (inputId, controller) {
+    var self = this;
+    self.controller = controller;
+    self.inputId = inputId;
+    var handler = autoCompleteHandler(inputId, controller, controller.ROLE_REVIEWER);
+
+    $(inputId).autocomplete({
+        serviceUrl: pyroutes.url('user_autocomplete_data'),
+        minChars: 2,
+        maxHeight: 400,
+        deferRequestBy: 300, //miliseconds
+        showNoSuggestionNotice: true,
+        tabDisabled: true,
+        autoSelectFirst: true,
+        params: {
+            user_id: templateContext.rhodecode_user.user_id,
+            user_groups: true,
+            user_groups_expand: true,
+            skip_default_user: true
+        },
+        formatResult: autocompleteFormatResult,
+        lookupFilter: autocompleteFilterResult,
+        onSelect: handler
+    });
 };
 
+/**
+ * Observers autocomplete
+ */
+var ObserverAutoComplete = function(inputId, controller) {
+    var self = this;
+    self.controller = controller;
+    self.inputId = inputId;
+    var handler = autoCompleteHandler(inputId, controller, controller.ROLE_OBSERVER);
+
+    $(inputId).autocomplete({
+        serviceUrl: pyroutes.url('user_autocomplete_data'),
+        minChars: 2,
+        maxHeight: 400,
+        deferRequestBy: 300, //miliseconds
+        showNoSuggestionNotice: true,
+        tabDisabled: true,
+        autoSelectFirst: true,
+        params: {
+            user_id: templateContext.rhodecode_user.user_id,
+            user_groups: true,
+            user_groups_expand: true,
+            skip_default_user: true
+        },
+        formatResult: autocompleteFormatResult,
+        lookupFilter: autocompleteFilterResult,
+        onSelect: handler
+    });
+}
+
 
 window.VersionController = function () {
     var self = this;
     this.$verSource = $('input[name=ver_source]');
     this.$verTarget = $('input[name=ver_target]');
     this.$showVersionDiff = $('#show-version-diff');
 
     this.adjustRadioSelectors = function (curNode) {
         var getVal = function (item) {
-            if (item == 'latest') {
+            if (item === 'latest') {
                 return Number.MAX_SAFE_INTEGER
             }
             else {
                 return parseInt(item)
             }
         };
 
         var curVal = getVal($(curNode).val());
         var cleared = false;
 
         $.each(self.$verSource, function (index, value) {
             var elVal = getVal($(value).val());
 
             if (elVal > curVal) {
                 if ($(value).is(':checked')) {
                     cleared = true;
                 }
                 $(value).attr('disabled', 'disabled');
                 $(value).removeAttr('checked');
                 $(value).css({'opacity': 0.1});
             }
             else {
                 $(value).css({'opacity': 1});
                 $(value).removeAttr('disabled');
             }
         });
 
         if (cleared) {
             // if we unchecked an active, set the next one to same loc.
             $(this.$verSource).filter('[value={0}]'.format(
                 curVal)).attr('checked', 'checked');
         }
 
         self.setLockAction(false,
             $(curNode).data('verPos'),
             $(this.$verSource).filter(':checked').data('verPos')
         );
     };
 
 
     this.attachVersionListener = function () {
         self.$verTarget.change(function (e) {
             self.adjustRadioSelectors(this)
         });
         self.$verSource.change(function (e) {
             self.adjustRadioSelectors(self.$verTarget.filter(':checked'))
         });
     };
 
     this.init = function () {
 
         var curNode = self.$verTarget.filter(':checked');
         self.adjustRadioSelectors(curNode);
         self.setLockAction(true);
         self.attachVersionListener();
 
     };
 
     this.setLockAction = function (state, selectedVersion, otherVersion) {
         var $showVersionDiff = this.$showVersionDiff;
 
         if (state) {
             $showVersionDiff.attr('disabled', 'disabled');
             $showVersionDiff.addClass('disabled');
             $showVersionDiff.html($showVersionDiff.data('labelTextLocked'));
         }
         else {
             $showVersionDiff.removeAttr('disabled');
             $showVersionDiff.removeClass('disabled');
 
             if (selectedVersion == otherVersion) {
                 $showVersionDiff.html($showVersionDiff.data('labelTextShow'));
             } else {
                 $showVersionDiff.html($showVersionDiff.data('labelTextDiff'));
             }
         }
 
     };
 
     this.showVersionDiff = function () {
         var target = self.$verTarget.filter(':checked');
         var source = self.$verSource.filter(':checked');
 
         if (target.val() && source.val()) {
             var params = {
                 'pull_request_id': templateContext.pull_request_data.pull_request_id,
                 'repo_name': templateContext.repo_name,
                 'version': target.val(),
                 'from_version': source.val()
             };
             window.location = pyroutes.url('pullrequest_show', params)
         }
 
         return false;
     };
 
     this.toggleVersionView = function (elem) {
 
         if (this.$showVersionDiff.is(':visible')) {
             $('.version-pr').hide();
             this.$showVersionDiff.hide();
             $(elem).html($(elem).data('toggleOn'))
         } else {
             $('.version-pr').show();
             this.$showVersionDiff.show();
             $(elem).html($(elem).data('toggleOff'))
         }
 
         return false
     };
 
 };
 
 
 window.UpdatePrController = function () {
     var self = this;
     this.$updateCommits = $('#update_commits');
     this.$updateCommitsSwitcher = $('#update_commits_switcher');
 
     this.lockUpdateButton = function (label) {
         self.$updateCommits.attr('disabled', 'disabled');
         self.$updateCommitsSwitcher.attr('disabled', 'disabled');
 
         self.$updateCommits.addClass('disabled');
         self.$updateCommitsSwitcher.addClass('disabled');
 
         self.$updateCommits.removeClass('btn-primary');
         self.$updateCommitsSwitcher.removeClass('btn-primary');
 
         self.$updateCommits.text(_gettext(label));
     };
 
     this.isUpdateLocked = function () {
         return self.$updateCommits.attr('disabled') !== undefined;
     };
 
     this.updateCommits = function (curNode) {
         if (self.isUpdateLocked()) {
             return
         }
         self.lockUpdateButton(_gettext('Updating...'));
         updateCommits(
             templateContext.repo_name,
             templateContext.pull_request_data.pull_request_id);
     };
 
     this.forceUpdateCommits = function () {
         if (self.isUpdateLocked()) {
             return
         }
         self.lockUpdateButton(_gettext('Force updating...'));
         var force = true;
         updateCommits(
             templateContext.repo_name,
             templateContext.pull_request_data.pull_request_id, force);
     };
 };
 
+
 /**
  * Reviewer display panel
  */
 window.ReviewersPanel = {
     editButton: null,
     closeButton: null,
     addButton: null,
     removeButtons: null,
     reviewRules: null,
     setReviewers: null,
 
     setSelectors: function () {
         var self = this;
         self.editButton = $('#open_edit_reviewers');
         self.closeButton =$('#close_edit_reviewers');
         self.addButton = $('#add_reviewer');
         self.removeButtons = $('.reviewer_member_remove,.reviewer_member_mandatory_remove');
     },
 
     init: function (reviewRules, setReviewers) {
         var self = this;
         self.setSelectors();
 
         this.reviewRules = reviewRules;
         this.setReviewers = setReviewers;
 
         this.editButton.on('click', function (e) {
             self.edit();
         });
         this.closeButton.on('click', function (e) {
             self.close();
             self.renderReviewers();
         });
 
         self.renderReviewers();
 
     },
 
     renderReviewers: function () {
+        if (this.setReviewers.reviewers === undefined) {
+            return
+        }
+        if (this.setReviewers.reviewers.length === 0) {
+            reviewersController.emptyReviewersTable('<tr id="reviewer-empty-msg"><td colspan="6">No reviewers</td></tr>');
+            return
+        }
 
-        $('#review_members').html('')
+        reviewersController.emptyReviewersTable();
+
         $.each(this.setReviewers.reviewers, function (key, val) {
-            var member = val;
 
-            var entry = renderTemplate('reviewMemberEntry', {
-                'member': member,
-                'mandatory': member.mandatory,
-                'reasons': member.reasons,
-                'allowed_to_update': member.allowed_to_update,
-                'review_status': member.review_status,
-                'review_status_label': member.review_status_label,
-                'user_group': member.user_group,
-                'create': false
-            });
+            var member = val;
+            if (member.role === reviewersController.ROLE_REVIEWER) {
+                var entry = renderTemplate('reviewMemberEntry', {
+                    'member': member,
+                    'mandatory': member.mandatory,
+                    'role': member.role,
+                    'reasons': member.reasons,
+                    'allowed_to_update': member.allowed_to_update,
+                    'review_status': member.review_status,
+                    'review_status_label': member.review_status_label,
+                    'user_group': member.user_group,
+                    'create': false
+                });
 
-            $('#review_members').append(entry)
+                $(reviewersController.$reviewMembers.selector).append(entry)
+            }
         });
+
         tooltipActivate();
-
     },
 
     edit: function (event) {
         this.editButton.hide();
         this.closeButton.show();
         this.addButton.show();
         $(this.removeButtons.selector).css('visibility', 'visible');
         // review rules
         reviewersController.loadReviewRules(this.reviewRules);
     },
 
     close: function (event) {
         this.editButton.show();
         this.closeButton.hide();
         this.addButton.hide();
         $(this.removeButtons.selector).css('visibility', 'hidden');
         // hide review rules
-        reviewersController.hideReviewRules()
+        reviewersController.hideReviewRules();
     }
 };
 
+/**
+ * Reviewer display panel
+ */
+window.ObserversPanel = {
+    editButton: null,
+    closeButton: null,
+    addButton: null,
+    removeButtons: null,
+    reviewRules: null,
+    setReviewers: null,
+
+    setSelectors: function () {
+        var self = this;
+        self.editButton = $('#open_edit_observers');
+        self.closeButton =$('#close_edit_observers');
+        self.addButton = $('#add_observer');
+        self.removeButtons = $('.observer_member_remove,.observer_member_mandatory_remove');
+    },
+
+    init: function (reviewRules, setReviewers) {
+        var self = this;
+        self.setSelectors();
+
+        this.reviewRules = reviewRules;
+        this.setReviewers = setReviewers;
+
+        this.editButton.on('click', function (e) {
+            self.edit();
+        });
+        this.closeButton.on('click', function (e) {
+            self.close();
+            self.renderObservers();
+        });
+
+        self.renderObservers();
+
+    },
+
+    renderObservers: function () {
+        if (this.setReviewers.observers === undefined) {
+            return
+        }
+        if (this.setReviewers.observers.length === 0) {
+            reviewersController.emptyObserversTable('<tr id="observer-empty-msg"><td colspan="6">No observers</td></tr>');
+            return
+        }
+
+        reviewersController.emptyObserversTable();
+
+        $.each(this.setReviewers.observers, function (key, val) {
+            var member = val;
+            if (member.role === reviewersController.ROLE_OBSERVER) {
+                var entry = renderTemplate('reviewMemberEntry', {
+                    'member': member,
+                    'mandatory': member.mandatory,
+                    'role': member.role,
+                    'reasons': member.reasons,
+                    'allowed_to_update': member.allowed_to_update,
+                    'review_status': member.review_status,
+                    'review_status_label': member.review_status_label,
+                    'user_group': member.user_group,
+                    'create': false
+                });
+
+                $(reviewersController.$observerMembers.selector).append(entry)
+            }
+        });
+
+        tooltipActivate();
+    },
+
+    edit: function (event) {
+        this.editButton.hide();
+        this.closeButton.show();
+        this.addButton.show();
+        $(this.removeButtons.selector).css('visibility', 'visible');
+    },
+
+    close: function (event) {
+        this.editButton.show();
+        this.closeButton.hide();
+        this.addButton.hide();
+        $(this.removeButtons.selector).css('visibility', 'hidden');
+    }
+
+};
+
+window.PRDetails = {
+    editButton: null,
+    closeButton: null,
+    deleteButton: null,
+    viewFields: null,
+    editFields: null,
+
+    setSelectors: function () {
+        var self = this;
+        self.editButton = $('#open_edit_pullrequest')
+        self.closeButton = $('#close_edit_pullrequest')
+        self.deleteButton = $('#delete_pullrequest')
+        self.viewFields = $('#pr-desc, #pr-title')
+        self.editFields = $('#pr-desc-edit, #pr-title-edit, .pr-save')
+    },
+
+    init: function () {
+        var self = this;
+        self.setSelectors();
+        self.editButton.on('click', function (e) {
+            self.edit();
+        });
+        self.closeButton.on('click', function (e) {
+            self.view();
+        });
+    },
+
+    edit: function (event) {
+        var cmInstance = $('#pr-description-input').get(0).MarkupForm.cm;
+        this.viewFields.hide();
+        this.editButton.hide();
+        this.deleteButton.hide();
+        this.closeButton.show();
+        this.editFields.show();
+        cmInstance.refresh();
+    },
+
+    view: function (event) {
+        this.editButton.show();
+        this.deleteButton.show();
+        this.editFields.hide();
+        this.closeButton.hide();
+        this.viewFields.show();
+    }
+};
 
 /**
  * OnLine presence using channelstream
  */
 window.ReviewerPresenceController = function (channel) {
     var self = this;
     this.channel = channel;
     this.users = {};
 
     this.storeUsers = function (users) {
         self.users = {}
         $.each(users, function (index, value) {
             var userId = value.state.id;
             self.users[userId] = value.state;
         })
     }
 
     this.render = function () {
         $.each($('.reviewer_entry'), function (index, value) {
             var userData = $(value).data();
             if (self.users[userData.reviewerUserId] !== undefined) {
                 $(value).find('.presence-state').show();
             } else {
                 $(value).find('.presence-state').hide();
             }
         })
     };
 
     this.handlePresence = function (data) {
         if (data.type == 'presence' && data.channel === self.channel) {
             this.storeUsers(data.users);
             this.render()
         }
     };
 
     this.handleChannelUpdate = function (data) {
         if (data.channel === this.channel) {
             this.storeUsers(data.state.users);
             this.render()
         }
 
     };
 
     /* subscribe to the current presence */
     $.Topic('/connection_controller/presence').subscribe(this.handlePresence.bind(this));
     /* subscribe to updates e.g connect/disconnect */
     $.Topic('/connection_controller/channel_update').subscribe(this.handleChannelUpdate.bind(this));
 
 };
 
 window.refreshComments = function (version) {
     version = version || templateContext.pull_request_data.pull_request_version || '';
 
     // Pull request case
     if (templateContext.pull_request_data.pull_request_id !== null) {
         var params = {
             'pull_request_id': templateContext.pull_request_data.pull_request_id,
             'repo_name': templateContext.repo_name,
             'version': version,
         };
         var loadUrl = pyroutes.url('pullrequest_comments', params);
     } // commit case
     else {
         return
     }
 
     var currentIDs = []
     $.each($('.comment'), function (idx, element) {
         currentIDs.push($(element).data('commentId'));
     });
-    var data = {"comments[]": currentIDs};
+    var data = {"comments": currentIDs};
 
     var $targetElem = $('.comments-content-table');
     $targetElem.css('opacity', 0.3);
-    $targetElem.load(
-        loadUrl, data, function (responseText, textStatus, jqXHR) {
-            if (jqXHR.status !== 200) {
-                return false;
-            }
-            var $counterElem = $('#comments-count');
-            var newCount = $(responseText).data('counter');
-            if (newCount !== undefined) {
-                var callback = function () {
-                    $counterElem.animate({'opacity': 1.00}, 200)
-                    $counterElem.html(newCount);
-                };
-                $counterElem.animate({'opacity': 0.15}, 200, callback);
-            }
 
-            $targetElem.css('opacity', 1);
-            tooltipActivate();
+    var success = function (data) {
+        var $counterElem = $('#comments-count');
+        var newCount = $(data).data('counter');
+        if (newCount !== undefined) {
+            var callback = function () {
+                $counterElem.animate({'opacity': 1.00}, 200)
+                $counterElem.html(newCount);
+            };
+            $counterElem.animate({'opacity': 0.15}, 200, callback);
         }
-    );
+
+        $targetElem.css('opacity', 1);
+        $targetElem.html(data);
+        tooltipActivate();
+    }
+
+    ajaxPOST(loadUrl, data, success, null, {})
+
 }
 
 window.refreshTODOs = function (version) {
     version = version || templateContext.pull_request_data.pull_request_version || '';
     // Pull request case
     if (templateContext.pull_request_data.pull_request_id !== null) {
         var params = {
             'pull_request_id': templateContext.pull_request_data.pull_request_id,
             'repo_name': templateContext.repo_name,
             'version': version,
         };
         var loadUrl = pyroutes.url('pullrequest_comments', params);
     } // commit case
     else {
         return
     }
 
     var currentIDs = []
     $.each($('.comment'), function (idx, element) {
         currentIDs.push($(element).data('commentId'));
     });
 
-    var data = {"comments[]": currentIDs};
+    var data = {"comments": currentIDs};
     var $targetElem = $('.todos-content-table');
     $targetElem.css('opacity', 0.3);
-    $targetElem.load(
-        loadUrl, data, function (responseText, textStatus, jqXHR) {
-            if (jqXHR.status !== 200) {
-                return false;
-            }
-            var $counterElem = $('#todos-count')
-            var newCount = $(responseText).data('counter');
-            if (newCount !== undefined) {
-                var callback = function () {
-                    $counterElem.animate({'opacity': 1.00}, 200)
-                    $counterElem.html(newCount);
-                };
-                $counterElem.animate({'opacity': 0.15}, 200, callback);
-            }
 
-            $targetElem.css('opacity', 1);
-            tooltipActivate();
+    var success = function (data) {
+        var $counterElem = $('#todos-count')
+        var newCount = $(data).data('counter');
+        if (newCount !== undefined) {
+            var callback = function () {
+                $counterElem.animate({'opacity': 1.00}, 200)
+                $counterElem.html(newCount);
+            };
+            $counterElem.animate({'opacity': 0.15}, 200, callback);
         }
-    );
+
+        $targetElem.css('opacity', 1);
+        $targetElem.html(data);
+        tooltipActivate();
+    }
+
+    ajaxPOST(loadUrl, data, success, null, {})
+
 }
 
 window.refreshAllComments = function (version) {
     version = version || templateContext.pull_request_data.pull_request_version || '';
 
     refreshComments(version);
     refreshTODOs(version);
 };
+
+window.sidebarComment = function (commentId) {
+    var jsonData = $('#commentHovercard{0}'.format(commentId)).data('commentJsonB64');
+    if (!jsonData) {
+        return 'Failed to load comment {0}'.format(commentId)
+    }
+    var funcData = JSON.parse(atob(jsonData));
+    return renderTemplate('sideBarCommentHovercard', funcData)
+};

rhodecode/public/js/src/rhodecode/utils/ajax.js

@@ -1,178 +1,182 b''
 // # Copyright (C) 2010-2020 RhodeCode GmbH
 // #
 // # This program is free software: you can redistribute it and/or modify
 // # it under the terms of the GNU Affero General Public License, version 3
 // # (only), as published by the Free Software Foundation.
 // #
 // # 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 Affero General Public License
 // # along with this program.  If not, see <http://www.gnu.org/licenses/>.
 // #
 // # This program is dual-licensed. If you wish to learn more about the
 // # RhodeCode Enterprise Edition, including its added features, Support services,
 // # and proprietary license terms, please see https://rhodecode.com/licenses/
 
 /**
 * turns objects into GET query string
 */
 var toQueryString = function(o) {
   if(typeof o === 'string') {
     return o;
   }
   if(typeof o !== 'object') {
     return false;
   }
   var _p, _qs = [];
   for(_p in o) {
     _qs.push(encodeURIComponent(_p) + '=' + encodeURIComponent(o[_p]));
   }
   return _qs.join('&');
 };
 
 /**
 * ajax call wrappers
 */
 
 var ajaxGET = function (url, success, failure) {
     var sUrl = url;
     var request = $.ajax({
         url: sUrl,
         headers: {'X-PARTIAL-XHR': true}
         })
         .done(function (data) {
             success(data);
         })
         .fail(function (jqXHR, textStatus, errorThrown) {
             if (failure) {
                 failure(jqXHR, textStatus, errorThrown);
             } else {
                 var message = formatErrorMessage(jqXHR, textStatus, errorThrown);
                 ajaxErrorSwal(message);
             }
         });
     return request;
 };
 
-var ajaxPOST = function (url, postData, success, failure) {
-    var sUrl = url;
-    var postData = toQueryString(postData);
-    var request = $.ajax({
+var ajaxPOST = function (url, postData, success, failure, options) {
+
+    var ajaxSettings = $.extend({
         type: 'POST',
-        url: sUrl,
-        data: postData,
+        url: url,
+        data: toQueryString(postData),
         headers: {'X-PARTIAL-XHR': true}
-        })
+    }, options);
+
+    var request = $.ajax(
+        ajaxSettings
+        )
         .done(function (data) {
             success(data);
         })
         .fail(function (jqXHR, textStatus, errorThrown) {
             if (failure) {
                 failure(jqXHR, textStatus, errorThrown);
             } else {
                 var message = formatErrorMessage(jqXHR, textStatus, errorThrown);
                 ajaxErrorSwal(message);
             }
         });
     return request;
 };
 
 
 SwalNoAnimation = Swal.mixin({
     confirmButtonColor: '#84a5d2',
     cancelButtonColor: '#e85e4d',
     showClass: {
         popup: 'swal2-noanimation',
         backdrop: 'swal2-noanimation'
     },
     hideClass: {
         popup: '',
         backdrop: ''
     },
 })
 
 
 /* Example usage:
 *
   error: function(jqXHR, textStatus, errorThrown) {
     var prefix = "Error while fetching entries.\n"
     var message = formatErrorMessage(jqXHR, textStatus, errorThrown, prefix);
     ajaxErrorSwal(message);
    }
 *
 * */
 function formatErrorMessage(jqXHR, textStatus, errorThrown, prefix) {
     if(typeof prefix === "undefined") {
         prefix = ''
     }
 
     if (jqXHR.status === 0) {
         return (prefix + 'Not connected.\nPlease verify your network connection.');
     } else if (jqXHR.status == 401) {
         return (prefix + 'Unauthorized access. [401]');
     } else if (jqXHR.status == 404) {
         return (prefix + 'The requested page not found. [404]');
     } else if (jqXHR.status == 500) {
         return (prefix + 'Internal Server Error [500].');
     } else if (jqXHR.status == 503) {
         return (prefix + 'Service unavailable [503].');
     } else if (errorThrown === 'parsererror') {
         return (prefix + 'Requested JSON parse failed.');
     } else if (errorThrown === 'timeout') {
         return (prefix + 'Time out error.');
     } else if (errorThrown === 'abort') {
         return (prefix + 'Ajax request aborted.');
     } else {
-        return (prefix + 'Uncaught Error.\n' + jqXHR.responseText);
+        var errInfo = 'Uncaught Error. code: {0}\n'.format(jqXHR.status)
+        return (prefix + errInfo + jqXHR.responseText);
     }
 }
 
 function ajaxErrorSwal(message, title) {
 
     var title = (typeof title !== 'undefined') ? title : _gettext('Ajax Request Error');
 
     SwalNoAnimation.fire({
         icon: 'error',
         title: title,
         html: '<span style="white-space: pre-line">{0}</span>'.format(message),
         showClass: {
             popup: 'swal2-noanimation',
             backdrop: 'swal2-noanimation'
         },
         hideClass: {
             popup: '',
             backdrop: ''
         }
     })
 }
 
 /*
 * use in onclick attributes e.g
 * onclick="submitConfirm(event, this, _gettext('Confirm to delete '), _gettext('Confirm Delete'), 'what we delete')">
 * */
 function submitConfirm(event, self, question, confirmText, htmlText) {
     if (htmlText === "undefined") {
         htmlText = null;
     }
     if (confirmText === "undefined") {
         confirmText = _gettext('Delete')
     }
     event.preventDefault();
 
     SwalNoAnimation.fire({
       title: question,
       icon: 'warning',
       html: htmlText,
 
       showCancelButton: true,
 
       confirmButtonText: confirmText
     }).then(function(result) {
       if (result.value) {
           $(self).closest("form").submit();
       }
     })
 }
  No newline at end of file

rhodecode/templates/base/sidebar.mako

@@ -1,142 +1,147 b''
 ## snippet for sidebar elements
 ## usage:
 ##    <%namespace name="sidebar" file="/base/sidebar.mako"/>
 ##    ${sidebar.comments_table()}
 <%namespace name="base" file="/base/base.mako"/>
 
 <%def name="comments_table(comments, counter_num, todo_comments=False, existing_ids=None, is_pr=True)">
     <%
         if todo_comments:
             cls_ = 'todos-content-table'
             def sorter(entry):
                 user_id = entry.author.user_id
                 resolved = '1' if entry.resolved else '0'
                 if user_id == c.rhodecode_user.user_id:
                     # own comments first
                     user_id = 0
                 return '{}'.format(str(entry.comment_id).zfill(10000))
         else:
             cls_ = 'comments-content-table'
             def sorter(entry):
                 user_id = entry.author.user_id
                 return '{}'.format(str(entry.comment_id).zfill(10000))
 
         existing_ids = existing_ids or []
 
     %>
 
     <table class="todo-table ${cls_}" data-total-count="${len(comments)}" data-counter="${counter_num}">
 
      % for loop_obj, comment_obj in h.looper(reversed(sorted(comments, key=sorter))):
          <%
             display = ''
             _cls = ''
          %>
 
          <%
              comment_ver_index = comment_obj.get_index_version(getattr(c, 'versions', []))
              prev_comment_ver_index = 0
              if loop_obj.previous:
                 prev_comment_ver_index = loop_obj.previous.get_index_version(getattr(c, 'versions', []))
 
              ver_info = None
              if getattr(c, 'versions', []):
                 ver_info = c.versions[comment_ver_index-1] if comment_ver_index else None
          %>
          <% hidden_at_ver = comment_obj.outdated_at_version_js(c.at_version_num) %>
          <% is_from_old_ver = comment_obj.older_than_version_js(c.at_version_num) %>
          <%
          if (prev_comment_ver_index > comment_ver_index):
            comments_ver_divider = comment_ver_index
          else:
             comments_ver_divider = None
          %>
 
           % if todo_comments:
               % if comment_obj.resolved:
                   <% _cls = 'resolved-todo' %>
                   <% display = 'none' %>
               % endif
           % else:
               ## SKIP TODOs we display them in other area
               % if comment_obj.is_todo:
                   <% display = 'none' %>
               % endif
               ## Skip outdated comments
               % if comment_obj.outdated:
                   <% display = 'none' %>
                   <% _cls = 'hidden-comment' %>
               % endif
           % endif
 
           % if not todo_comments and comments_ver_divider:
           <tr class="old-comments-marker">
               <td colspan="3">
                   % if ver_info:
                     <code>v${comments_ver_divider} ${h.age_component(ver_info.created_on, time_is_local=True, tooltip=False)}</code>
                   % else:
                     <code>v${comments_ver_divider}</code>
                   % endif
               </td>
           </tr>
 
           % endif
 
           <tr class="${_cls}" style="display: ${display};" data-sidebar-comment-id="${comment_obj.comment_id}">
               <td class="td-todo-number">
                   <%
                     version_info = ''
                     if is_pr:
                         version_info = (' made in older version (v{})'.format(comment_ver_index) if is_from_old_ver == 'true' else ' made in this version')
                   %>
-
-                  <script type="text/javascript">
-                      // closure function helper
-                      var sidebarComment${comment_obj.comment_id} = function() {
-                        return renderTemplate('sideBarCommentHovercard', {
-                            version_info: "${version_info}",
-                            file_name: "${comment_obj.f_path}",
-                            line_no: "${comment_obj.line_no}",
-                            outdated: ${h.json.dumps(comment_obj.outdated)},
-                            inline: ${h.json.dumps(comment_obj.is_inline)},
-                            is_todo: ${h.json.dumps(comment_obj.is_todo)},
-                            created_on: "${h.format_date(comment_obj.created_on)}",
-                            datetime: "${comment_obj.created_on}${h.get_timezone(comment_obj.created_on, time_is_local=True)}",
-                            review_status: "${(comment_obj.review_status or '')}"
-                        })
-                      }
-                  </script>
-
-                  % if comment_obj.outdated:
-                    <i class="icon-comment-toggle tooltip-hovercard" data-hovercard-url="javascript:sidebarComment${comment_obj.comment_id}()"></i>
-                  % elif comment_obj.is_inline:
-                    <i class="icon-code tooltip-hovercard" data-hovercard-url="javascript:sidebarComment${comment_obj.comment_id}()"></i>
-                  % else:
-                    <i class="icon-comment tooltip-hovercard" data-hovercard-url="javascript:sidebarComment${comment_obj.comment_id}()"></i>
+                  ## NEW, since refresh
+                  % if existing_ids and comment_obj.comment_id not in existing_ids:
+                      <div class="tooltip" style="position: absolute; left: 8px" title="New comment">
+                          !
+                      </div>
                   % endif
 
-                  ## NEW, since refresh
-                  % if existing_ids and comment_obj.comment_id not in existing_ids:
-                      <span class="tag">NEW</span>
-                  % endif
+                  <%
+                      data = h.json.dumps({
+                            'comment_id': comment_obj.comment_id,
+                            'version_info': version_info,
+                            'file_name': comment_obj.f_path,
+                            'line_no': comment_obj.line_no,
+                            'outdated': comment_obj.outdated,
+                            'inline': comment_obj.is_inline,
+                            'is_todo': comment_obj.is_todo,
+                            'created_on': h.format_date(comment_obj.created_on),
+                            'datetime': '{}{}'.format(comment_obj.created_on, h.get_timezone(comment_obj.created_on, time_is_local=True)),
+                            'review_status': (comment_obj.review_status or '')
+                      })
+
+                      if comment_obj.outdated:
+                          icon = 'icon-comment-toggle'
+                      elif comment_obj.is_inline:
+                          icon = 'icon-code'
+                      else:
+                          icon = 'icon-comment'
+                  %>
+
+                  <i id="commentHovercard${comment_obj.comment_id}"
+                     class="${icon} tooltip-hovercard"
+                     data-hovercard-url="javascript:sidebarComment(${comment_obj.comment_id})"
+                     data-comment-json-b64='${h.b64(data)}'>
+                  </i>
+
               </td>
 
               <td class="td-todo-gravatar">
                   ${base.gravatar(comment_obj.author.email, 16, user=comment_obj.author, tooltip=True, extra_class=['no-margin'])}
               </td>
               <td class="todo-comment-text-wrapper">
                   <div class="todo-comment-text ${('todo-resolved' if comment_obj.resolved else '')}">
                       <a class="${('todo-resolved' if comment_obj.resolved else '')} permalink"
                          href="#comment-${comment_obj.comment_id}"
                          onclick="return Rhodecode.comments.scrollToComment($('#comment-${comment_obj.comment_id}'), 0, ${hidden_at_ver})">
 
                          ${h.chop_at_smart(comment_obj.text, '\n', suffix_if_chopped='...')}
                       </a>
                   </div>
               </td>
           </tr>
      % endfor
 
     </table>
 
 </%def>
  No newline at end of file

rhodecode/templates/changeset/changeset.mako

@@ -1,431 +1,431 b''
 ## -*- coding: utf-8 -*-
 
 <%inherit file="/base/base.mako"/>
 <%namespace name="base" file="/base/base.mako"/>
 <%namespace name="diff_block" file="/changeset/diff_block.mako"/>
 <%namespace name="file_base" file="/files/base.mako"/>
 <%namespace name="sidebar" file="/base/sidebar.mako"/>
 
 
 <%def name="title()">
     ${_('{} Commit').format(c.repo_name)} - ${h.show_id(c.commit)}
     %if c.rhodecode_name:
         &middot; ${h.branding(c.rhodecode_name)}
     %endif
 </%def>
 
 <%def name="menu_bar_nav()">
     ${self.menu_items(active='repositories')}
 </%def>
 
 <%def name="menu_bar_subnav()">
     ${self.repo_menu(active='commits')}
 </%def>
 
 <%def name="main()">
 <script type="text/javascript">
     // TODO: marcink switch this to pyroutes
     AJAX_COMMENT_DELETE_URL = "${h.route_path('repo_commit_comment_delete',repo_name=c.repo_name,commit_id=c.commit.raw_id,comment_id='__COMMENT_ID__')}";
     templateContext.commit_data.commit_id = "${c.commit.raw_id}";
 </script>
 
 <div class="box">
 
   <div class="summary">
 
       <div class="fieldset">
         <div class="left-content">
           <%
               rc_user = h.discover_user(c.commit.author_email)
           %>
           <div class="left-content-avatar">
             ${base.gravatar(c.commit.author_email, 30, tooltip=(True if rc_user else False), user=rc_user)}
           </div>
 
           <div class="left-content-message">
           <div class="fieldset collapsable-content no-hide" data-toggle="summary-details">
             <div class="commit truncate-wrap">${h.urlify_commit_message(h.chop_at_smart(c.commit.message, '\n', suffix_if_chopped='...'), c.repo_name)}</div>
           </div>
 
           <div class="fieldset collapsable-content" data-toggle="summary-details" style="display: none">
             <div class="commit">${h.urlify_commit_message(c.commit.message,c.repo_name)}</div>
           </div>
 
           <div class="fieldset" data-toggle="summary-details">
             <div class="">
                 <table>
                 <tr class="file_author">
 
                     <td>
                         <span class="user commit-author">${h.link_to_user(rc_user or c.commit.author)}</span>
                         <span class="commit-date">- ${h.age_component(c.commit.date)}</span>
                     </td>
 
                     <td>
                     ## second cell for consistency with files
                     </td>
                 </tr>
                 </table>
             </div>
           </div>
 
         </div>
         </div>
 
           <div class="right-content">
 
           <div data-toggle="summary-details">
               <div class="tags tags-main">
                 <code><a href="${h.route_path('repo_commit',repo_name=c.repo_name,commit_id=c.commit.raw_id)}">${h.show_id(c.commit)}</a></code>
                 <i class="tooltip icon-clipboard clipboard-action" data-clipboard-text="${c.commit.raw_id}" title="${_('Copy the full commit id')}"></i>
                 ${file_base.refs(c.commit)}
 
                 ## phase
                 % if hasattr(c.commit, 'phase') and getattr(c.commit, 'phase') != 'public':
                     <span class="tag phase-${c.commit.phase} tooltip" title="${_('Commit phase')}">
                         <i class="icon-info"></i>${c.commit.phase}
                     </span>
                 % endif
 
                 ## obsolete commits
                 % if getattr(c.commit, 'obsolete', False):
                     <span class="tag obsolete-${c.commit.obsolete} tooltip" title="${_('Evolve State')}">
                         ${_('obsolete')}
                     </span>
                 % endif
 
                 ## hidden commits
                 % if getattr(c.commit, 'hidden', False):
                     <span class="tag hidden-${c.commit.hidden} tooltip" title="${_('Evolve State')}">
                         ${_('hidden')}
                     </span>
                 % endif
               </div>
 
               <span id="parent_link" class="tag tagtag">
                 <a href="#parentCommit" title="${_('Parent Commit')}"><i class="icon-left icon-no-margin"></i>${_('parent')}</a>
               </span>
 
               <span id="child_link" class="tag tagtag">
                 <a href="#childCommit" title="${_('Child Commit')}">${_('child')}<i class="icon-right icon-no-margin"></i></a>
               </span>
 
           </div>
 
         </div>
       </div>
 
       <div class="fieldset collapsable-content" data-toggle="summary-details" style="display: none;">
         <div class="left-label-summary">
           <p>${_('Diff options')}:</p>
           <div class="right-label-summary">
             <div class="diff-actions">
               <a href="${h.route_path('repo_commit_raw',repo_name=c.repo_name,commit_id=c.commit.raw_id)}">
                 ${_('Raw Diff')}
               </a>
                |
               <a href="${h.route_path('repo_commit_patch',repo_name=c.repo_name,commit_id=c.commit.raw_id)}">
                 ${_('Patch Diff')}
               </a>
                |
               <a href="${h.route_path('repo_commit_download',repo_name=c.repo_name,commit_id=c.commit.raw_id,_query=dict(diff='download'))}">
                 ${_('Download Diff')}
               </a>
             </div>
           </div>
         </div>
       </div>
 
       <div class="clear-fix"></div>
 
       <div  class="btn-collapse" data-toggle="summary-details">
         ${_('Show More')}
       </div>
 
   </div>
 
   <div class="cs_files">
     <%namespace name="cbdiffs" file="/codeblocks/diffs.mako"/>
     ${cbdiffs.render_diffset_menu(c.changes[c.commit.raw_id], commit=c.commit)}
     ${cbdiffs.render_diffset(
       c.changes[c.commit.raw_id], commit=c.commit, use_comments=True,
       inline_comments=c.inline_comments,
       show_todos=False)}
   </div>
 
     ## template for inline comment form
     <%namespace name="comment" file="/changeset/changeset_file_comment.mako"/>
 
     ## comments heading with count
     <div class="comments-heading">
         <i class="icon-comment"></i>
         ${_('General Comments')} ${len(c.comments)}
     </div>
 
     ## render comments
     ${comment.generate_comments(c.comments)}
 
     ## main comment form and it status
     ${comment.comments(h.route_path('repo_commit_comment_create', repo_name=c.repo_name, commit_id=c.commit.raw_id),
                        h.commit_status(c.rhodecode_db_repo, c.commit.raw_id))}
 </div>
 
 ### NAV SIDEBAR
 <aside class="right-sidebar right-sidebar-expanded" id="commit-nav-sticky" style="display: none">
     <div class="sidenav navbar__inner" >
         ## TOGGLE
         <div class="sidebar-toggle" onclick="toggleSidebar(); return false">
             <a href="#toggleSidebar" class="grey-link-action">
 
             </a>
         </div>
 
         ## CONTENT
         <div class="sidebar-content">
 
             ## RULES SUMMARY/RULES
             <div class="sidebar-element clear-both">
                 <% vote_title = _ungettext(
                         'Status calculated based on votes from {} reviewer',
-                        'Status calculated based on votes from {} reviewers', len(c.allowed_reviewers)).format(len(c.allowed_reviewers))
+                        'Status calculated based on votes from {} reviewers', c.reviewers_count).format(c.reviewers_count)
                 %>
 
                 <div class="tooltip right-sidebar-collapsed-state" style="display: none" onclick="toggleSidebar(); return false" title="${vote_title}">
                     <i class="icon-circle review-status-${c.commit_review_status}"></i>
-                    ${len(c.allowed_reviewers)}
+                    ${c.reviewers_count}
                 </div>
             </div>
 
             ## REVIEWERS
             <div class="right-sidebar-expanded-state pr-details-title">
                 <span class="tooltip sidebar-heading" title="${vote_title}">
                     <i class="icon-circle review-status-${c.commit_review_status}"></i>
                     ${_('Reviewers')}
                 </span>
             </div>
 
             <div id="reviewers" class="right-sidebar-expanded-state pr-details-content reviewers">
 
                 <table id="review_members" class="group_members">
                 ## This content is loaded via JS and ReviewersPanel
                 </table>
 
             </div>
 
             ## TODOs
             <div class="sidebar-element clear-both">
                 <div class="tooltip right-sidebar-collapsed-state" style="display: none" onclick="toggleSidebar(); return false" title="TODOs">
                   <i class="icon-flag-filled"></i>
                   <span id="todos-count">${len(c.unresolved_comments)}</span>
                 </div>
 
                 <div class="right-sidebar-expanded-state pr-details-title">
                       ## Only show unresolved, that is only what matters
                       <span class="sidebar-heading noselect" onclick="refreshTODOs(); return false">
                       <i class="icon-flag-filled"></i>
                       TODOs
                       </span>
 
                       % if c.resolved_comments:
                           <span class="block-right action_button last-item noselect" onclick="$('.unresolved-todo-text').toggle(); return toggleElement(this, '.resolved-todo');" data-toggle-on="Show resolved" data-toggle-off="Hide resolved">Show resolved</span>
                       % else:
                           <span class="block-right last-item noselect">Show resolved</span>
                       % endif
 
                   </div>
 
                 <div class="right-sidebar-expanded-state pr-details-content">
                     % if c.unresolved_comments + c.resolved_comments:
                       ${sidebar.comments_table(c.unresolved_comments + c.resolved_comments, len(c.unresolved_comments), todo_comments=True, is_pr=False)}
                     % else:
                         <table>
                             <tr>
                                 <td>
                                     ${_('No TODOs yet')}
                                 </td>
                             </tr>
                         </table>
                     % endif
                 </div>
             </div>
 
             ## COMMENTS
             <div class="sidebar-element clear-both">
                 <div class="tooltip right-sidebar-collapsed-state" style="display: none" onclick="toggleSidebar(); return false" title="${_('Comments')}">
                     <i class="icon-comment" style="color: #949494"></i>
                     <span id="comments-count">${len(c.inline_comments_flat+c.comments)}</span>
                     <span class="display-none" id="general-comments-count">${len(c.comments)}</span>
                     <span class="display-none" id="inline-comments-count">${len(c.inline_comments_flat)}</span>
                 </div>
 
                 <div class="right-sidebar-expanded-state pr-details-title">
                   <span class="sidebar-heading noselect" onclick="refreshComments(); return false">
                     <i class="icon-comment" style="color: #949494"></i>
                     ${_('Comments')}
                   </span>
 
                 </div>
 
                 <div class="right-sidebar-expanded-state pr-details-content">
                 % if c.inline_comments_flat + c.comments:
                     ${sidebar.comments_table(c.inline_comments_flat + c.comments, len(c.inline_comments_flat+c.comments), is_pr=False)}
                 % else:
                     <table>
                         <tr>
                             <td>
                                 ${_('No Comments yet')}
                             </td>
                         </tr>
                     </table>
                 % endif
                 </div>
 
             </div>
 
         </div>
 
     </div>
 </aside>
 
 ## FORM FOR MAKING JS ACTION AS CHANGESET COMMENTS
 <script type="text/javascript">
     window.setReviewersData = ${c.commit_set_reviewers_data_json | n};
 
     $(document).ready(function () {
         var boxmax = parseInt($('#trimmed_message_box').css('max-height'), 10);
 
         if ($('#trimmed_message_box').height() === boxmax) {
             $('#message_expand').show();
         }
 
         $('#message_expand').on('click', function (e) {
             $('#trimmed_message_box').css('max-height', 'none');
             $(this).hide();
         });
 
         $('.show-inline-comments').on('click', function (e) {
             var boxid = $(this).attr('data-comment-id');
             var button = $(this);
 
             if (button.hasClass("comments-visible")) {
                 $('#{0} .inline-comments'.format(boxid)).each(function (index) {
                     $(this).hide();
                 });
                 button.removeClass("comments-visible");
             } else {
                 $('#{0} .inline-comments'.format(boxid)).each(function (index) {
                     $(this).show();
                 });
                 button.addClass("comments-visible");
             }
         });
 
         // next links
         $('#child_link').on('click', function (e) {
             // fetch via ajax what is going to be the next link, if we have
             // >1 links show them to user to choose
             if (!$('#child_link').hasClass('disabled')) {
                 $.ajax({
                     url: '${h.route_path('repo_commit_children',repo_name=c.repo_name, commit_id=c.commit.raw_id)}',
                     success: function (data) {
                         if (data.results.length === 0) {
                             $('#child_link').html("${_('No Child Commits')}").addClass('disabled');
                         }
                         if (data.results.length === 1) {
                             var commit = data.results[0];
                             window.location = pyroutes.url('repo_commit', {
                                 'repo_name': '${c.repo_name}',
                                 'commit_id': commit.raw_id
                             });
                         } else if (data.results.length === 2) {
                             $('#child_link').addClass('disabled');
                             $('#child_link').addClass('double');
 
                             var _html = '';
                             _html += '<a title="__title__" href="__url__"><span class="tag branchtag"><i class="icon-code-fork"></i>__branch__</span> __rev__</a> '
                                     .replace('__branch__', data.results[0].branch)
                                     .replace('__rev__', 'r{0}:{1}'.format(data.results[0].revision, data.results[0].raw_id.substr(0, 6)))
                                     .replace('__title__', data.results[0].message)
                                     .replace('__url__', pyroutes.url('repo_commit', {
                                         'repo_name': '${c.repo_name}',
                                         'commit_id': data.results[0].raw_id
                                     }));
                             _html += ' | ';
                             _html += '<a title="__title__" href="__url__"><span class="tag branchtag"><i class="icon-code-fork"></i>__branch__</span> __rev__</a> '
                                     .replace('__branch__', data.results[1].branch)
                                     .replace('__rev__', 'r{0}:{1}'.format(data.results[1].revision, data.results[1].raw_id.substr(0, 6)))
                                     .replace('__title__', data.results[1].message)
                                     .replace('__url__', pyroutes.url('repo_commit', {
                                         'repo_name': '${c.repo_name}',
                                         'commit_id': data.results[1].raw_id
                                     }));
                             $('#child_link').html(_html);
                         }
                     }
                 });
                 e.preventDefault();
             }
         });
 
         // prev links
         $('#parent_link').on('click', function (e) {
             // fetch via ajax what is going to be the next link, if we have
             // >1 links show them to user to choose
             if (!$('#parent_link').hasClass('disabled')) {
                 $.ajax({
                     url: '${h.route_path("repo_commit_parents",repo_name=c.repo_name, commit_id=c.commit.raw_id)}',
                     success: function (data) {
                         if (data.results.length === 0) {
                             $('#parent_link').html('${_('No Parent Commits')}').addClass('disabled');
                         }
                         if (data.results.length === 1) {
                             var commit = data.results[0];
                             window.location = pyroutes.url('repo_commit', {
                                 'repo_name': '${c.repo_name}',
                                 'commit_id': commit.raw_id
                             });
                         } else if (data.results.length === 2) {
                             $('#parent_link').addClass('disabled');
                             $('#parent_link').addClass('double');
 
                             var _html = '';
                             _html += '<a title="__title__" href="__url__"><span class="tag branchtag"><i class="icon-code-fork"></i>__branch__</span> __rev__</a>'
                                     .replace('__branch__', data.results[0].branch)
                                     .replace('__rev__', 'r{0}:{1}'.format(data.results[0].revision, data.results[0].raw_id.substr(0, 6)))
                                     .replace('__title__', data.results[0].message)
                                     .replace('__url__', pyroutes.url('repo_commit', {
                                         'repo_name': '${c.repo_name}',
                                         'commit_id': data.results[0].raw_id
                                     }));
                             _html += ' | ';
                             _html += '<a title="__title__" href="__url__"><span class="tag branchtag"><i class="icon-code-fork"></i>__branch__</span> __rev__</a>'
                                     .replace('__branch__', data.results[1].branch)
                                     .replace('__rev__', 'r{0}:{1}'.format(data.results[1].revision, data.results[1].raw_id.substr(0, 6)))
                                     .replace('__title__', data.results[1].message)
                                     .replace('__url__', pyroutes.url('repo_commit', {
                                         'repo_name': '${c.repo_name}',
                                         'commit_id': data.results[1].raw_id
                                     }));
                             $('#parent_link').html(_html);
                         }
                     }
                 });
                 e.preventDefault();
             }
         });
 
         // browse tree @ revision
         $('#files_link').on('click', function (e) {
             window.location = '${h.route_path('repo_files:default_path',repo_name=c.repo_name, commit_id=c.commit.raw_id)}';
             e.preventDefault();
         });
 
         ReviewersPanel.init(null, setReviewersData);
 
         var channel = '${c.commit_broadcast_channel}';
         new ReviewerPresenceController(channel)
 
     })
 </script>
 
 </%def>

rhodecode/templates/debug_style/collapsable-content.html

@@ -1,962 +1,962 b''
 ## -*- coding: utf-8 -*-
 <%inherit file="/debug_style/index.html"/>
 
 <%def name="breadcrumbs_links()">
     ${h.link_to(_('Style'), h.route_path('debug_style_home'))}
     &raquo;
     ${c.active}
 </%def>
 
 
 <%def name="real_main()">
 <div class="box">
     <div class="title">
         ${self.breadcrumbs()}
     </div>
 
     <div class='sidebar-col-wrapper'>
     ${self.sidebar()}
 
       <div class="main-content">
 
         <h2>Collapsable Content</h2>
         <p>Where a section may have a very long list of information, it can be desirable to use collapsable content. There is a premade function for showing/hiding elements, though its use may or may not be practical, depending on the situation. Use it, or don't, on a case-by-case basis.</p>
 
         <p><strong>To use the collapsable-content function:</strong> Create a toggle button using <code>&lt;div class="btn-collapse"&gt;Show More&lt;/div&gt;</code> and a data attribute using <code>data-toggle</code>. Clicking this button will toggle any sibling element(s) containing the class <code>collapsable-content</code> and an identical <code>data-toggle</code> attribute. It will also change the button to read "Show Less"; another click toggles it back to the previous state. Ideally, use pre-existing elements and add the class and attribute; creating a new div around the existing content may lead to unexpected results, as the toggle function will use <code>display:block</code> if no previous display specification was found.
         </p>
         <p>Notes:</p>
         <ul>
           <li>Changes made to the text of the button will require adjustment to the function, but for the sake of consistency and user experience, this is best avoided. </li>
           <li>Collapsable content inside of a pjax loaded container will require <code>collapsableContent();</code> to be called from within the container. No variables are necessary.</li>
         </ul>
 
       </div>  <!-- .main-content  -->
     </div>  <!-- .sidebar-col-wrapper  -->
 </div> <!-- .box -->
 
   <!-- CONTENT -->
   <div id="content" class="wrapper">
 
       <div class="main">
 
 <div class="box">
   <div class="title">
     <h1>
         Diff: enable filename with spaces on diffs
     </h1>
     <h1>
             <i class="icon-hg" ></i>
 
             <i class="icon-lock"></i>
         <span><a href="/rhodecode-momentum">rhodecode-momentum</a></span>
 
     </h1>
   </div>
 
   <div class="box pr-summary">
       <div class="summary-details block-left">
 
         <div class="pr-details-title">
 
     Pull request #720 From Tue, 17 Feb 2015 16:21:38
 <div class="btn-collapse" data-toggle="description">Show More</div>
         </div>
         <div id="summary" class="fields pr-details-content">
            <div class="field">
             <div class="label-summary">
                 <label>Origin:</label>
             </div>
             <div class="input">
                 <div>
                     <span class="tag">
                         <a href="/andersonsantos/rhodecode-momentum-fork#fix_574">book: fix_574</a>
                     </span>
                     <span class="clone-url">
                         <a href="/andersonsantos/rhodecode-momentum-fork">https://code.rhodecode.com/andersonsantos/rhodecode-momentum-fork</a>
                     </span>
                 </div>
                 <div>
                      <br>
                         <input type="text"  value="hg pull -r 46b3d50315f0 https://code.rhodecode.com/andersonsantos/rhodecode-momentum-fork" readonly="readonly">
                 </div>
             </div>
            </div>
            <div class="field">
             <div class="label-summary">
                 <label>Review:</label>
             </div>
             <div class="input">
               <div class="flag_status under_review tooltip pull-left" title="Pull request status calculated from votes"></div>
                 <span class="changeset-status-lbl tooltip" title="Pull request status calculated from votes">
                   Under Review
                 </span>
 
             </div>
            </div>
             <div class="field collapsable-content" data-toggle="description">
              <div class="label-summary">
                  <label>Description:</label>
              </div>
              <div class="input">
                  <div class="pr-description">Fixing issue <a class="issue- tracker-link" href="http://bugs.rhodecode.com/issues/574">#  574</a>, changing regex for capturing filenames</div>
              </div>
             </div>
             <div class="field collapsable-content" data-toggle="description">
              <div class="label-summary">
                  <label>Comments:</label>
              </div>
              <div class="input">
                  <div>
                      <div class="comments-number">
                          <a href="#inline-comments-container">0 Pull request   comments</a>,
                          0 Inline Comments
                      </div>
                  </div>
               </div>
           </div>
         </div>
       </div>
       <div>
         <div class="reviewers-title block-right">
           <div class="pr-details-title">
               Author
           </div>
         </div>
         <div class="block-right pr-details-content reviewers">
             <ul class="group_members">
               <li>
                 <img class="gravatar" src="https://secure.gravatar.com/avatar/72706ebd30734451af9ff3fb59f05ff1?d=identicon&amp;s=32" height="16" width="16">
                 <span class="user"> <a href="/_profiles/lolek">lolek (Lolek Santos)</a></span>
               </li>
             </ul>
         </div>
         <div class="reviewers-title block-right">
           <div class="pr-details-title">
               Pull request reviewers
               <span class="btn-collapse" data-toggle="reviewers">Show More</span>
           </div>
 
         </div>
         <div id="reviewers" class="block-right pr-details-content reviewers">
 
             <ul id="review_members" class="group_members">
               <li id="reviewer_70">
                 <div class="reviewers_member">
                     <div class="reviewer_status tooltip pull-left" title="Not Reviewed">
                       <div class="flag_status rejected pull-left reviewer_member_status"></div>
                     </div>
                   <img class="gravatar" src="https://secure.gravatar.com/avatar/153a0fab13160b3e64a2cbc7c0373506?d=identicon&amp;s=32" height="16" width="16">
                   <span class="user"> <a href="/_profiles/jenkins-tests">jenkins-tests</a> (reviewer)</span>
                 </div>
                   <input id="reviewer_70_input" type="hidden" value="70" name="review_members">
-                  <div class="reviewer_member_remove action_button" onclick="removeReviewMember(70, true)" style="visibility: hidden;">
+                  <div class="reviewer_member_remove action_button" onclick="removeMember(70, true)" style="visibility: hidden;">
                     <i class="icon-remove"></i>
                   </div>
               </li>
               <li id="reviewer_33" class="collapsable-content" data-toggle="reviewers">
                 <div class="reviewers_member">
                     <div class="reviewer_status tooltip pull-left" title="Not Reviewed">
                       <div class="flag_status approved pull-left reviewer_member_status"></div>
                     </div>
                   <img class="gravatar" src="https://secure.gravatar.com/avatar/ffd6a317ec2b66be880143cd8459d0d9?d=identicon&amp;s=32" height="16" width="16">
                   <span class="user"> <a href="/_profiles/jenkins-tests">garbas (Rok Garbas)</a> (reviewer)</span>
                 </div>
               </li>
               <li id="reviewer_2" class="collapsable-content" data-toggle="reviewers">
                 <div class="reviewers_member">
                     <div class="reviewer_status tooltip pull-left" title="Not Reviewed">
                       <div class="flag_status not_reviewed pull-left reviewer_member_status"></div>
                     </div>
                   <img class="gravatar" src="https://secure.gravatar.com/avatar/aad9d40cac1259ea39b5578554ad9d64?d=identicon&amp;s=32" height="16" width="16">
                   <span class="user"> <a href="/_profiles/jenkins-tests">marcink (Marcin Kuzminski)</a> (reviewer)</span>
                 </div>
               </li>
               <li id="reviewer_36" class="collapsable-content" data-toggle="reviewers">
                 <div class="reviewers_member">
                     <div class="reviewer_status tooltip pull-left" title="Not Reviewed">
                       <div class="flag_status approved pull-left reviewer_member_status"></div>
                     </div>
                   <img class="gravatar" src="https://secure.gravatar.com/avatar/7a4da001a0af0016ed056ab523255db9?d=identicon&amp;s=32" height="16" width="16">
                   <span class="user"> <a href="/_profiles/jenkins-tests">johbo (Johannes Bornhold)</a> (reviewer)</span>
                 </div>
               </li>
               <li id="reviewer_47" class="collapsable-content" data-toggle="reviewers">
                 <div class="reviewers_member">
                     <div class="reviewer_status tooltip pull-left" title="Not Reviewed">
                       <div class="flag_status under_review pull-left reviewer_member_status"></div>
                     </div>
                   <img class="gravatar" src="https://secure.gravatar.com/avatar/8f6dc00dce79d6bd7d415be5cea6a008?d=identicon&amp;s=32" height="16" width="16">
                   <span class="user"> <a href="/_profiles/jenkins-tests">lisaq (Lisa Quatmann)</a> (reviewer)</span>
                 </div>
               </li>
               <li id="reviewer_49" class="collapsable-content" data-toggle="reviewers">
                 <div class="reviewers_member">
                     <div class="reviewer_status tooltip pull-left" title="Not Reviewed">
                       <div class="flag_status approved pull-left reviewer_member_status"></div>
                     </div>
                   <img class="gravatar" src="https://secure.gravatar.com/avatar/89f722927932a8f737a0feafb03a606e?d=identicon&amp;s=32" height="16" width="16">
                   <span class="user"> <a href="/_profiles/jenkins-tests">paris (Paris Kolios)</a> (reviewer)</span>
                 </div>
               </li>
               <li id="reviewer_50" class="collapsable-content" data-toggle="reviewers">
                 <div class="reviewers_member">
                     <div class="reviewer_status tooltip pull-left" title="Not Reviewed">
                       <div class="flag_status approved pull-left reviewer_member_status"></div>
                     </div>
                   <img class="gravatar" src="https://secure.gravatar.com/avatar/081322c975e8545ec269372405fbd016?d=identicon&amp;s=32" height="16" width="16">
                   <span class="user"> <a href="/_profiles/jenkins-tests">ergo (Marcin Lulek)</a> (reviewer)</span>
                 </div>
               </li>
               <li id="reviewer_54" class="collapsable-content" data-toggle="reviewers">
                 <div class="reviewers_member">
                     <div class="reviewer_status tooltip pull-left" title="Not Reviewed">
                       <div class="flag_status under_review pull-left reviewer_member_status"></div>
                     </div>
                   <img class="gravatar" src="https://secure.gravatar.com/avatar/72706ebd30734451af9ff3fb59f05ff1?d=identicon&amp;s=32" height="16" width="16">
                   <span class="user"> <a href="/_profiles/jenkins-tests">anderson (Anderson Santos)</a> (reviewer)</span>
                 </div>
               </li>
               <li id="reviewer_57" class="collapsable-content" data-toggle="reviewers">
                 <div class="reviewers_member">
                     <div class="reviewer_status tooltip pull-left" title="Not Reviewed">
                       <div class="flag_status approved pull-left reviewer_member_status"></div>
                     </div>
                   <img class="gravatar" src="https://secure.gravatar.com/avatar/23e2ee8f5fd462cba8129a40cc1e896c?d=identicon&amp;s=32" height="16" width="16">
                   <span class="user"> <a href="/_profiles/jenkins-tests">gmgauthier (Greg Gauthier)</a> (reviewer)</span>
                 </div>
               </li>
               <li id="reviewer_31" class="collapsable-content" data-toggle="reviewers">
                 <div class="reviewers_member">
                     <div class="reviewer_status tooltip pull-left" title="Not Reviewed">
                       <div class="flag_status under_review pull-left reviewer_member_status"></div>
                     </div>
                   <img class="gravatar" src="https://secure.gravatar.com/avatar/0c9a7e6674b6f0b35d98dbe073e3f0ab?d=identicon&amp;s=32" height="16" width="16">
                   <span class="user"> <a href="/_profiles/jenkins-tests">ostrobel (Oliver Strobel)</a> (reviewer)</span>
                 </div>
               </li>
             </ul>
           <div id="add_reviewer_input" class="ac" style="display: none;">
           </div>
         </div>
         </div>
       </div>
   </div>
   <div class="box">
       <div class="table" >
           <div id="changeset_compare_view_content">
               <div class="compare_view_commits_title">
                   <h2>Compare View: 6 commits<span class="btn-collapse" data-toggle="commits">Show More</span></h2>
 
               </div>
               <div class="container">
 
 
     <table class="rctable compare_view_commits">
     <tr>
         <th>Time</th>
         <th>Author</th>
         <th>Commit</th>
         <th></th>
         <th>Title</th>
     </tr>
         <tr id="row-7e83e5cd7812dd9e055ce30e77c65cdc08154b43" commit_id="7e83e5cd7812dd9e055ce30e77c65cdc08154b43" class="compare_select">
             <td class="td-time">
                 <span class="tooltip" title="3 hours and 23 minutes ago" tt_title="3 hours and 23 minutes ago">2015-02-18 10:13:34</span>
             </td>
             <td class="td-user">
                 <div class="gravatar_with_user">
                     <img class="gravatar" alt="gravatar" src="https://secure.gravatar.com/avatar/02cc31cea73b88b7209ba302c5967a9d?d=identicon&amp;s=16">
                     <span title="Lolek Santos <[e-mail]>" class="user">brian (Brian Butler)</span>
                 </div>
             </td>
             <td class="td-hash">
                 <code>
                     <a href="/brian/documentation-rep/changeset/7e83e5cd7812dd9e055ce30e77c65cdc08154b43">r395:7e83e5cd7812</a>
                 </code>
             </td>
             <td class="expand_commit" data-commit-id="7e83e5cd7812dd9e055ce30e77c65cdc08154b43" title="Expand commit message">
                 <div class="show_more_col">
                 <i class="show_more"></i>
                 </div>
             </td>
             <td class="mid td-description">
                 <div class="log-container truncate-wrap">
                     <div id="c-7e83e5cd7812dd9e055ce30e77c65cdc08154b43" class="message truncate">rep: added how we doc to guide</div>
                   </div>
             </td>
         </tr>
         <tr id="row-48ce1581bdb3aa7679c246cbdd3fb030623f5c87" commit_id="48ce1581bdb3aa7679c246cbdd3fb030623f5c87" class="compare_select">
             <td class="td-time">
                 <span class="tooltip" title="4 hours and 18 minutes ago">2015-02-18 09:18:31</span>
             </td>
             <td class="td-user">
                 <div class="gravatar_with_user">
                     <img class="gravatar" alt="gravatar" src="https://secure.gravatar.com/avatar/02cc31cea73b88b7209ba302c5967a9d?d=identicon&amp;s=16">
                     <span title="Lolek Santos <[e-mail]>" class="user">brian (Brian Butler)</span>
                 </div>
             </td>
             <td class="td-hash">
                 <code>
                     <a href="/brian/documentation-rep/changeset/48ce1581bdb3aa7679c246cbdd3fb030623f5c87">r394:48ce1581bdb3</a>
                 </code>
             </td>
             <td class="expand_commit" data-commit-id="48ce1581bdb3aa7679c246cbdd3fb030623f5c87" title="Expand commit message">
                 <div class="show_more_col">
                 <i class="show_more"></i>
                 </div>
             </td>
             <td class="mid td-description">
                 <div class="log-container truncate-wrap">
                     <div id="c-48ce1581bdb3aa7679c246cbdd3fb030623f5c87" class="message truncate">repo 0004 - typo</div>
                   </div>
             </td>
         </tr>
         <tr id="row-982d857aafb4c71e7686e419c32b71c9a837257d" commit_id="982d857aafb4c71e7686e419c32b71c9a837257d" class="compare_select collapsable-content" data-toggle="commits">
             <td class="td-time">
                 <span class="tooltip" title="4 hours and 22 minutes ago">2015-02-18 09:14:45</span>
             </td>
             <td class="td-user">
                 <span class="gravatar" commit_id="982d857aafb4c71e7686e419c32b71c9a837257d">
                     <img alt="gravatar" src="https://secure.gravatar.com/avatar/02cc31cea73b88b7209ba302c5967a9d?d=identicon&amp;s=28" height="14" width="14">
                 </span>
                 <span class="author">brian (Brian Butler)</span>
             </td>
             <td class="td-hash">
                 <code>
                     <a href="/brian/documentation-rep/changeset/982d857aafb4c71e7686e419c32b71c9a837257d">r393:982d857aafb4</a>
                 </code>
             </td>
             <td class="expand_commit" data-commit-id="982d857aafb4c71e7686e419c32b71c9a837257d" title="Expand commit message">
                 <div class="show_more_col">
                 <i class="show_more"></i>
                 </div>
             </td>
             <td class="mid td-description">
                 <div class="log-container truncate-wrap">
                     <div id="c-982d857aafb4c71e7686e419c32b71c9a837257d" class="message truncate">internals: how to doc section added</div>
                   </div>
             </td>
         </tr>
         <tr id="row-4c7258ad1af6dae91bbaf87a933e3597e676fab8" commit_id="4c7258ad1af6dae91bbaf87a933e3597e676fab8" class="compare_select collapsable-content" data-toggle="commits">
             <td class="td-time">
                 <span class="tooltip" title="20 hours and 16 minutes ago">2015-02-17 17:20:44</span>
             </td>
             <td class="td-user">
                 <span class="gravatar" commit_id="4c7258ad1af6dae91bbaf87a933e3597e676fab8">
                     <img alt="gravatar" src="https://secure.gravatar.com/avatar/02cc31cea73b88b7209ba302c5967a9d?d=identicon&amp;s=28" height="14" width="14">
                 </span>
                 <span class="author">brian (Brian Butler)</span>
             </td>
             <td class="td-hash">
                 <code>
                     <a href="/brian/documentation-rep/changeset/4c7258ad1af6dae91bbaf87a933e3597e676fab8">r392:4c7258ad1af6</a>
                 </code>
             </td>
             <td class="expand_commit" data-commit-id="4c7258ad1af6dae91bbaf87a933e3597e676fab8" title="Expand commit message">
                 <div class="show_more_col">
                 <i class="show_more"></i>
                 </div>
             </td>
             <td class="mid td-description">
                 <div class="log-container truncate-wrap">
                     <div id="c-4c7258ad1af6dae91bbaf87a933e3597e676fab8" class="message truncate">REP: 0004 Documentation standards</div>
                   </div>
             </td>
         </tr>
         <tr id="row-46b3d50315f0f2b1f64485ac95af4f384948f9cb" commit_id="46b3d50315f0f2b1f64485ac95af4f384948f9cb" class="compare_select collapsable-content" data-toggle="commits">
             <td class="td-time">
                 <span class="tooltip" title="18 hours and 19 minutes ago">2015-02-17 16:18:49</span>
             </td>
             <td class="td-user">
                 <span class="gravatar" commit_id="46b3d50315f0f2b1f64485ac95af4f384948f9cb">
                     <img alt="gravatar" src="https://secure.gravatar.com/avatar/72706ebd30734451af9ff3fb59f05ff1?d=identicon&amp;s=28" height="14" width="14">
                 </span>
                 <span class="author">anderson (Anderson Santos)</span>
             </td>
             <td class="td-hash">
                 <code>
                     <a href="/andersonsantos/rhodecode-momentum-fork/changeset/46b3d50315f0f2b1f64485ac95af4f384948f9cb">r8743:46b3d50315f0</a>
                 </code>
             </td>
             <td class="expand_commit" data-commit-id="46b3d50315f0f2b1f64485ac95af4f384948f9cb" title="Expand commit message">
                 <div class="show_more_col">
                 <i class="show_more" ></i>
                 </div>
             </td>
             <td class="mid td-description">
                 <div class="log-container truncate-wrap">
                     <div id="c-46b3d50315f0f2b1f64485ac95af4f384948f9cb" class="message truncate">Diff: created tests for the diff with filenames with spaces</div>
                     
                   </div>
             </td>
         </tr>
         <tr id="row-1e57d2549bd6c34798075bf05ac39f708bb33b90" commit_id="1e57d2549bd6c34798075bf05ac39f708bb33b90" class="compare_select collapsable-content" data-toggle="commits">
             <td class="td-time">
                 <span class="tooltip" title="2 days ago">2015-02-16 10:06:08</span>
             </td>
             <td class="td-user">
                 <span class="gravatar" commit_id="1e57d2549bd6c34798075bf05ac39f708bb33b90">
                     <img alt="gravatar" src="https://secure.gravatar.com/avatar/72706ebd30734451af9ff3fb59f05ff1?d=identicon&amp;s=28" height="14" width="14">
                 </span>
                 <span class="author">anderson (Anderson Santos)</span>
             </td>
             <td class="td-hash">
                 <code>
                     <a href="/andersonsantos/rhodecode-momentum-fork/changeset/1e57d2549bd6c34798075bf05ac39f708bb33b90">r8742:1e57d2549bd6</a>
                 </code>
             </td>
             <td class="expand_commit" data-commit-id="1e57d2549bd6c34798075bf05ac39f708bb33b90" title="Expand commit message">
                 <div class="show_more_col">
                 <i class="show_more" ></i>
                 </div>
             </td>
             <td class="mid td-description">
                 <div class="log-container truncate-wrap">
                     <div id="c-1e57d2549bd6c34798075bf05ac39f708bb33b90" class="message truncate">Diff: fix renaming files with spaces <a class="issue-tracker-link" href="http://bugs.rhodecode.com/issues/574">#574</a></div>
                     
                   </div>
             </td>
         </tr>
     </table>
 </div>
 
 <script>
 $('.expand_commit').on('click',function(e){
     $(this).children('i').hide();
     var cid = $(this).data('commitId');
     $('#c-'+cid).css({'height': 'auto', 'margin': '.65em 1em .65em 0','white-space': 'pre-line', 'text-overflow': 'initial', 'overflow':'visible'})
     $('#t-'+cid).css({'height': 'auto', 'text-overflow': 'initial', 'overflow':'visible', 'white-space':'normal'})
 });
 $('.compare_select').on('click',function(e){
     var cid = $(this).attr('commit_id');
     $('#row-'+cid).toggleClass('hl', !$('#row-'+cid).hasClass('hl'));
 });
 </script>
               <div class="cs_files_title">
                   <span class="cs_files_expand">
                       <span id="expand_all_files">Expand All</span> | <span id="collapse_all_files">Collapse All</span>
                   </span>
                   <h2>
                       7 files changed: 55 inserted, 9 deleted
                   </h2>
               </div>
               <div class="cs_files">
               <table class="compare_view_files">
 
                   <tr class="cs_A expand_file" fid="c--efbe5b7a3f13">
                       <td class="cs_icon_td">
                           <span class="expand_file_icon" fid="c--efbe5b7a3f13"></span>
                       </td>
                       <td class="cs_icon_td">
                           <div class="flag_status not_reviewed hidden"></div>
                       </td>
                       <td id="a_c--efbe5b7a3f13">
                           <a class="compare_view_filepath" href="#a_c--efbe5b7a3f13">
                               rhodecode/tests/fixtures/git_diff_rename_file_with_spaces.diff
                           </a>
                           <span id="diff_c--efbe5b7a3f13" class="diff_links" style="display: none;">
                             <a href="/andersonsantos/rhodecode-momentum-fork/diff/rhodecode/tests/fixtures/git_diff_rename_file_with_spaces.diff?diff2=46b3d50315f0f2b1f64485ac95af4f384948f9cb&amp;diff1=b78e2376b986b2cf656a2b4390b09f303291c886&amp;fulldiff=1&amp;diff=diff">
                                 Unified Diff
                             </a>
                             |
                             <a href="/andersonsantos/rhodecode-momentum-fork/diff-2way/rhodecode/tests/fixtures/git_diff_rename_file_with_spaces.diff?diff2=46b3d50315f0f2b1f64485ac95af4f384948f9cb&amp;diff1=b78e2376b986b2cf656a2b4390b09f303291c886&amp;fulldiff=1&amp;diff=diff">
                                 Side-by-side Diff
                             </a>
                           </span>
                       </td>
                       <td>
                           <div class="changes pull-right"><div style="width:100px"><div class="added top-right-rounded-corner-mid bottom-right-rounded-corner-mid top-left-rounded-corner-mid bottom-left-rounded-corner-mid" style="width:100.0%">4</div><div class="deleted top-right-rounded-corner-mid bottom-right-rounded-corner-mid" style="width:0%"></div></div></div>
                           <div class="comment-bubble pull-right" data-path="rhodecode/tests/fixtures/git_diff_rename_file_with_spaces.diff">
                             <i class="icon-comment"></i>
                           </div>
                       </td>
                   </tr>
                   <tr id="tr_c--efbe5b7a3f13">
                     <td></td>
                     <td></td>
                     <td class="injected_diff" colspan="2">
 
  <div class="diff-container" id="diff-container-140716195039928">
     <div id="c--efbe5b7a3f13_target" ></div>
     <div id="c--efbe5b7a3f13" class="diffblock margined comm" >
         <div class="code-body">
             <div class="full_f_path" path="rhodecode/tests/fixtures/git_diff_rename_file_with_spaces.diff" style="display: none;"></div>
             <table class="code-difftable">
 <tr class="line context">
     <td class="add-comment-line"><span class="add-comment-content"></span></td>
     <td  class="lineno old"><a href="#rhodecodetestsfixturesgit_diff_rename_file_with_spacesdiff_o"></a></td>
     <td  class="lineno new"><a href="#rhodecodetestsfixturesgit_diff_rename_file_with_spacesdiff_n"></a></td>
     <td class="code no-comment">
         <pre>new file 100644</pre>
     </td>
 </tr>
 <tr class="line add">
     <td class="add-comment-line"><span class="add-comment-content"><a href="#"><span class="icon-comment-add"></span></a></span></td>
     <td  class="lineno old"><a href="#rhodecodetestsfixturesgit_diff_rename_file_with_spacesdiff_o"></a></td>
     <td id="rhodecodetestsfixturesgit_diff_rename_file_with_spacesdiff_n1" class="lineno new"><a href="#rhodecodetestsfixturesgit_diff_rename_file_with_spacesdiff_n1">1</a></td>
     <td class="code">
         <pre>diff --git a/file_with_ spaces.txt b/file_with_  two spaces.txt
 </pre>
     </td>
 </tr>
 <tr class="line add">
     <td class="add-comment-line"><span class="add-comment-content"><a href="#"><span class="icon-comment-add"></span></a></span></td>
     <td  class="lineno old"><a href="#rhodecodetestsfixturesgit_diff_rename_file_with_spacesdiff_o"></a></td>
     <td id="rhodecodetestsfixturesgit_diff_rename_file_with_spacesdiff_n2" class="lineno new"><a href="#rhodecodetestsfixturesgit_diff_rename_file_with_spacesdiff_n2">2</a></td>
     <td class="code">
         <pre>similarity index 100%
 </pre>
     </td>
 </tr>
 <tr class="line add">
     <td class="add-comment-line"><span class="add-comment-content"><a href="#"><span class="icon-comment-add"></span></a></span></td>
     <td  class="lineno old"><a href="#rhodecodetestsfixturesgit_diff_rename_file_with_spacesdiff_o"></a></td>
     <td id="rhodecodetestsfixturesgit_diff_rename_file_with_spacesdiff_n3" class="lineno new"><a href="#rhodecodetestsfixturesgit_diff_rename_file_with_spacesdiff_n3">3</a></td>
     <td class="code">
         <pre>rename from file_with_ spaces.txt
 </pre>
     </td>
 </tr>
 <tr class="line add">
     <td class="add-comment-line"><span class="add-comment-content"><a href="#"><span class="icon-comment-add"></span></a></span></td>
     <td  class="lineno old"><a href="#rhodecodetestsfixturesgit_diff_rename_file_with_spacesdiff_o"></a></td>
     <td id="rhodecodetestsfixturesgit_diff_rename_file_with_spacesdiff_n4" class="lineno new"><a href="#rhodecodetestsfixturesgit_diff_rename_file_with_spacesdiff_n4">4</a></td>
     <td class="code">
         <pre>rename to file_with_  two spaces.txt
 </pre>
     </td>
 </tr>
 <tr class="line context">
     <td class="add-comment-line"><span class="add-comment-content"></span></td>
     <td  class="lineno old"><a href="#rhodecodetestsfixturesgit_diff_rename_file_with_spacesdiff_o...">...</a></td>
     <td  class="lineno new"><a href="#rhodecodetestsfixturesgit_diff_rename_file_with_spacesdiff_n...">...</a></td>
     <td class="code no-comment">
         <pre> No newline at end of file</pre>
     </td>
 </tr>
 </table>
         </div>
     </div>
   </div>
 
                     </td>
                   </tr>
                   <tr class="cs_A expand_file" fid="c--c21377f778f9">
                       <td class="cs_icon_td">
                           <span class="expand_file_icon" fid="c--c21377f778f9"></span>
                       </td>
                       <td class="cs_icon_td">
                           <div class="flag_status not_reviewed hidden"></div>
                       </td>
                       <td id="a_c--c21377f778f9">
                           <a class="compare_view_filepath" href="#a_c--c21377f778f9">
                               rhodecode/tests/fixtures/hg_diff_copy_file_with_spaces.diff
                           </a>
                           <span id="diff_c--c21377f778f9" class="diff_links" style="display: none;">
                             <a href="/andersonsantos/rhodecode-momentum-fork/diff/rhodecode/tests/fixtures/hg_diff_copy_file_with_spaces.diff?diff2=46b3d50315f0f2b1f64485ac95af4f384948f9cb&amp;diff1=b78e2376b986b2cf656a2b4390b09f303291c886&amp;fulldiff=1&amp;diff=diff">
                                 Unified Diff
                             </a>
                             |
                             <a href="/andersonsantos/rhodecode-momentum-fork/diff-2way/rhodecode/tests/fixtures/hg_diff_copy_file_with_spaces.diff?diff2=46b3d50315f0f2b1f64485ac95af4f384948f9cb&amp;diff1=b78e2376b986b2cf656a2b4390b09f303291c886&amp;fulldiff=1&amp;diff=diff">
                                 Side-by-side Diff
                             </a>
                           </span>
                       </td>
                       <td>
                           <div class="changes pull-right"><div style="width:100px"><div class="added top-right-rounded-corner-mid bottom-right-rounded-corner-mid top-left-rounded-corner-mid bottom-left-rounded-corner-mid" style="width:100.0%">3</div><div class="deleted top-right-rounded-corner-mid bottom-right-rounded-corner-mid" style="width:0%"></div></div></div>
                           <div class="comment-bubble pull-right" data-path="rhodecode/tests/fixtures/hg_diff_copy_file_with_spaces.diff">
                             <i class="icon-comment"></i>
                           </div>
                       </td>
                   </tr>
                   <tr id="tr_c--c21377f778f9">
                     <td></td>
                     <td></td>
                     <td class="injected_diff" colspan="2">
 
  <div class="diff-container" id="diff-container-140716195038344">
     <div id="c--c21377f778f9_target" ></div>
     <div id="c--c21377f778f9" class="diffblock margined comm" >
         <div class="code-body">
             <div class="full_f_path" path="rhodecode/tests/fixtures/hg_diff_copy_file_with_spaces.diff" style="display: none;"></div>
             <table class="code-difftable">
 <tr class="line context">
     <td class="add-comment-line"><span class="add-comment-content"></span></td>
     <td  class="lineno old"><a href="#rhodecodetestsfixtureshg_diff_copy_file_with_spacesdiff_o"></a></td>
     <td  class="lineno new"><a href="#rhodecodetestsfixtureshg_diff_copy_file_with_spacesdiff_n"></a></td>
     <td class="code no-comment">
         <pre>new file 100644</pre>
     </td>
 </tr>
 <tr class="line add">
     <td class="add-comment-line"><span class="add-comment-content"><a href="#"><span class="icon-comment-add"></span></a></span></td>
     <td  class="lineno old"><a href="#rhodecodetestsfixtureshg_diff_copy_file_with_spacesdiff_o"></a></td>
     <td id="rhodecodetestsfixtureshg_diff_copy_file_with_spacesdiff_n1" class="lineno new"><a href="#rhodecodetestsfixtureshg_diff_copy_file_with_spacesdiff_n1">1</a></td>
     <td class="code">
         <pre>diff --git a/file_changed_without_spaces.txt b/file_copied_ with  spaces.txt
 </pre>
     </td>
 </tr>
 <tr class="line add">
     <td class="add-comment-line"><span class="add-comment-content"><a href="#"><span class="icon-comment-add"></span></a></span></td>
     <td  class="lineno old"><a href="#rhodecodetestsfixtureshg_diff_copy_file_with_spacesdiff_o"></a></td>
     <td id="rhodecodetestsfixtureshg_diff_copy_file_with_spacesdiff_n2" class="lineno new"><a href="#rhodecodetestsfixtureshg_diff_copy_file_with_spacesdiff_n2">2</a></td>
     <td class="code">
         <pre>copy from file_changed_without_spaces.txt
 </pre>
     </td>
 </tr>
 <tr class="line add">
     <td class="add-comment-line"><span class="add-comment-content"><a href="#"><span class="icon-comment-add"></span></a></span></td>
     <td  class="lineno old"><a href="#rhodecodetestsfixtureshg_diff_copy_file_with_spacesdiff_o"></a></td>
     <td id="rhodecodetestsfixtureshg_diff_copy_file_with_spacesdiff_n3" class="lineno new"><a href="#rhodecodetestsfixtureshg_diff_copy_file_with_spacesdiff_n3">3</a></td>
     <td class="code">
         <pre>copy to file_copied_ with  spaces.txt
 </pre>
     </td>
 </tr>
 <tr class="line context">
     <td class="add-comment-line"><span class="add-comment-content"></span></td>
     <td  class="lineno old"><a href="#rhodecodetestsfixtureshg_diff_copy_file_with_spacesdiff_o...">...</a></td>
     <td  class="lineno new"><a href="#rhodecodetestsfixtureshg_diff_copy_file_with_spacesdiff_n...">...</a></td>
     <td class="code no-comment">
         <pre> No newline at end of file</pre>
     </td>
 </tr>
 </table>
         </div>
     </div>
   </div>
 
                     </td>
                   </tr>
                   <tr class="cs_A expand_file" fid="c--ee62085ad7a8">
                       <td class="cs_icon_td">
                           <span class="expand_file_icon" fid="c--ee62085ad7a8"></span>
                       </td>
                       <td class="cs_icon_td">
                           <div class="flag_status not_reviewed hidden"></div>
                       </td>
                       <td id="a_c--ee62085ad7a8">
                           <a class="compare_view_filepath" href="#a_c--ee62085ad7a8">
                               rhodecode/tests/fixtures/hg_diff_rename_file_with_spaces.diff
                           </a>
                           <span id="diff_c--ee62085ad7a8" class="diff_links" style="display: none;">
                             <a href="/andersonsantos/rhodecode-momentum-fork/diff/rhodecode/tests/fixtures/hg_diff_rename_file_with_spaces.diff?diff2=46b3d50315f0f2b1f64485ac95af4f384948f9cb&amp;diff1=b78e2376b986b2cf656a2b4390b09f303291c886&amp;fulldiff=1&amp;diff=diff">
                                 Unified Diff
                             </a>
                             |
                             <a href="/andersonsantos/rhodecode-momentum-fork/diff-2way/rhodecode/tests/fixtures/hg_diff_rename_file_with_spaces.diff?diff2=46b3d50315f0f2b1f64485ac95af4f384948f9cb&amp;diff1=b78e2376b986b2cf656a2b4390b09f303291c886&amp;fulldiff=1&amp;diff=diff">
                                 Side-by-side Diff
                             </a>
                           </span>
                       </td>
                       <td>
                           <div class="changes pull-right"><div style="width:100px"><div class="added top-right-rounded-corner-mid bottom-right-rounded-corner-mid top-left-rounded-corner-mid bottom-left-rounded-corner-mid" style="width:100.0%">3</div><div class="deleted top-right-rounded-corner-mid bottom-right-rounded-corner-mid" style="width:0%"></div></div></div>
                           <div class="comment-bubble pull-right" data-path="rhodecode/tests/fixtures/hg_diff_rename_file_with_spaces.diff">
                             <i class="icon-comment"></i>
                           </div>
                       </td>
                   </tr>
                   <tr id="tr_c--ee62085ad7a8">
                     <td></td>
                     <td></td>
                     <td class="injected_diff" colspan="2">
 
  <div class="diff-container" id="diff-container-140716195039496">
     <div id="c--ee62085ad7a8_target" ></div>
     <div id="c--ee62085ad7a8" class="diffblock margined comm" >
         <div class="code-body">
             <div class="full_f_path" path="rhodecode/tests/fixtures/hg_diff_rename_file_with_spaces.diff" style="display: none;"></div>
             <table class="code-difftable">
 <tr class="line context">
     <td class="add-comment-line"><span class="add-comment-content"></span></td>
     <td  class="lineno old"><a href="#rhodecodetestsfixtureshg_diff_rename_file_with_spacesdiff_o"></a></td>
     <td  class="lineno new"><a href="#rhodecodetestsfixtureshg_diff_rename_file_with_spacesdiff_n"></a></td>
     <td class="code no-comment">
         <pre>new file 100644</pre>
     </td>
 </tr>
 <tr class="line add">
     <td class="add-comment-line"><span class="add-comment-content"><a href="#"><span class="icon-comment-add"></span></a></span></td>
     <td  class="lineno old"><a href="#rhodecodetestsfixtureshg_diff_rename_file_with_spacesdiff_o"></a></td>
     <td id="rhodecodetestsfixtureshg_diff_rename_file_with_spacesdiff_n1" class="lineno new"><a href="#rhodecodetestsfixtureshg_diff_rename_file_with_spacesdiff_n1">1</a></td>
     <td class="code">
         <pre>diff --git a/file_ with update.txt b/file_changed _.txt
 </pre>
     </td>
 </tr>
 <tr class="line add">
     <td class="add-comment-line"><span class="add-comment-content"><a href="#"><span class="icon-comment-add"></span></a></span></td>
     <td  class="lineno old"><a href="#rhodecodetestsfixtureshg_diff_rename_file_with_spacesdiff_o"></a></td>
     <td id="rhodecodetestsfixtureshg_diff_rename_file_with_spacesdiff_n2" class="lineno new"><a href="#rhodecodetestsfixtureshg_diff_rename_file_with_spacesdiff_n2">2</a></td>
     <td class="code">
         <pre>rename from file_ with update.txt
 </pre>
     </td>
 </tr>
 <tr class="line add">
     <td class="add-comment-line"><span class="add-comment-content"><a href="#"><span class="icon-comment-add"></span></a></span></td>
     <td  class="lineno old"><a href="#rhodecodetestsfixtureshg_diff_rename_file_with_spacesdiff_o"></a></td>
     <td id="rhodecodetestsfixtureshg_diff_rename_file_with_spacesdiff_n3" class="lineno new"><a href="#rhodecodetestsfixtureshg_diff_rename_file_with_spacesdiff_n3">3</a></td>
     <td class="code">
         <pre>rename to file_changed _.txt</pre>
     </td>
 </tr>
 </table>
         </div>
     </div>
   </div>
 
                     </td>
                   </tr>
 
 </table>
         </div>
     </div>
   </div>
 
                     </td>
                   </tr>
               </table>
               </div>
           </div>
       </div>
 
 
 
 
 <div id="comment-inline-form-template" style="display: none;">
   <div class="comment-inline-form ac">
     <div class="overlay"><div class="overlay-text">Submitting...</div></div>
       <form action="#" class="inline-form" method="get">
       <div id="edit-container_{1}" class="clearfix">
         <div class="comment-title pull-left">
           Commenting on line {1}.
         </div>
         <div class="comment-help pull-right">
           Comments parsed using <a href="http://docutils.sourceforge.io/docs/user/rst/quickref.html">RST</a> syntax with <span  class="tooltip" title="Use @username inside this text to send notification to this RhodeCode user">@mention</span> support.
         </div>
             <div style="clear: both"></div>
             <textarea id="text_{1}" name="text" class="comment-block-ta ac-input"></textarea>
       </div>
       <div id="preview-container_{1}" class="clearfix" style="display: none;">
          <div class="comment-help">
               Comment preview
           </div>
           <div id="preview-box_{1}" class="preview-box"></div>
       </div>
       <div class="comment-button pull-right">
         <input type="hidden" name="f_path" value="{0}">
         <input type="hidden" name="line" value="{1}">
         <div id="preview-btn_{1}" class="btn btn-default">Preview</div>
         <div id="edit-btn_{1}" class="btn" style="display: none;">Edit</div>
         <input class="btn btn-success save-inline-form" id="save" name="save" type="submit" value="Comment" />
       </div>
       <div class="comment-button hide-inline-form-button">
       <input class="btn hide-inline-form" id="hide-inline-form" name="hide-inline-form" type="reset" value="Cancel" />
       </div>
       </form>
   </div>
 </div>
 
 
 
 <div class="comments">
     <div id="inline-comments-container">
 
     <h2>0 Pull Request Comments</h2>
 
 
     </div>
 
 </div>
 
 
 
 
 <div class="pull-request-merge">
 </div>
 <div class="comments">
     <div class="comment-form ac">
         <form action="/rhodecode-momentum/pull-request-comment/720" id="comments_form" method="POST">
 <div style="display: none;"><input id="csrf_token" name="csrf_token" type="hidden" value="6dbc0b19ac65237df65d57202a3e1f2df4153e38" /></div>
         <div id="edit-container" class="clearfix">
             <div class="comment-title pull-left">
               Create a comment on this Pull Request.
             </div>
             <div class="comment-help pull-right">
               Comments parsed using <a href="http://docutils.sourceforge.io/docs/user/rst/quickref.html">RST</a> syntax with <span  class="tooltip" title="Use @username inside this text to send notification to this RhodeCode user">@mention</span> support.
             </div>
              <div style="clear: both"></div>
              <textarea class="comment-block-ta" id="text" name="text"></textarea>
         </div>
 
         <div id="preview-container" class="clearfix" style="display: none;">
            <div class="comment-title">
                 Comment preview
             </div>
             <div id="preview-box" class="preview-box"></div>
         </div>
 
         <div id="comment_form_extras">
         </div>
         <div class="action-button pull-right">
             <div id="preview-btn" class="btn">
                 Preview
             </div>
             <div id="edit-btn" class="btn" style="display: none;">
                 Edit
             </div>
             <div class="comment-button">
                 <input class="btn btn-small btn-success comment-button-input" id="save" name="save" type="submit" value="Comment" />
             </div>
         </div>
         </form>
     </div>
 </div>
 <script>
 
 $(document).ready(function() {
 
     var cm = initCommentBoxCodeMirror('#text');
 
     // main form preview
     $('#preview-btn').on('click', function(e) {
         $('#preview-btn').hide();
         $('#edit-btn').show();
         var _text = cm.getValue();
         if (!_text) {
             return;
         }
         var post_data = {
             'text': _text,
             'renderer': DEFAULT_RENDERER,
             'csrf_token': CSRF_TOKEN
         };
         var previewbox = $('#preview-box');
         previewbox.addClass('unloaded');
         previewbox.html(_gettext('Loading ...'));
         $('#edit-container').hide();
         $('#preview-container').show();
 
         var url = pyroutes.url('repo_commit_comment_preview',
             {'repo_name': 'rhodecode-momentum', 'commit_id': '000000'});
 
         ajaxPOST(url, post_data, function(o) {
             previewbox.html(o);
             previewbox.removeClass('unloaded');
         });
     });
     $('#edit-btn').on('click', function(e) {
         $('#preview-btn').show();
         $('#edit-btn').hide();
         $('#edit-container').show();
         $('#preview-container').hide();
     });
 
     var formatChangeStatus = function(state, escapeMarkup) {
         var originalOption = state.element;
         return '<div class="flag_status ' + $(originalOption).data('status') + ' pull-left"></div>' +
                '<span>' + escapeMarkup(state.text) + '</span>';
     };
 
     var formatResult = function(result, container, query, escapeMarkup) {
         return formatChangeStatus(result, escapeMarkup);
     };
 
     var formatSelection = function(data, container, escapeMarkup) {
         return formatChangeStatus(data, escapeMarkup);
     };
 
     $('#change_status_general').select2({
         placeholder: "Status Review",
         formatResult: formatResult,
         formatSelection: formatSelection,
         containerCssClass: "drop-menu status_box_menu",
         dropdownCssClass: "drop-menu-dropdown",
         dropdownAutoWidth: true,
         minimumResultsForSearch: -1
     });
 });
 </script>
 
 
       <script type="text/javascript">
         // TODO: switch this to pyroutes
         AJAX_COMMENT_DELETE_URL = "/rhodecode-momentum/pull-request-comment/__COMMENT_ID__/delete";
 
         $(function(){
             ReviewerAutoComplete('#user');
 
             $('#open_edit_reviewers').on('click', function(e){
                 $('#open_edit_reviewers').hide();
                 $('#close_edit_reviewers').show();
                 $('#add_reviewer_input').show();
                 $('.reviewer_member_remove').css('visibility', 'visible');
             });
 
             $('#close_edit_reviewers').on('click', function(e){
                 $('#open_edit_reviewers').show();
                 $('#close_edit_reviewers').hide();
                 $('#add_reviewer_input').hide();
                 $('.reviewer_member_remove').css('visibility', 'hidden');
             });
 
             $('.show-inline-comments').on('change', function(e){
                 var show = 'none';
                 var target = e.currentTarget;
                 if(target.checked){
                     show = ''
                 }
                 var boxid = $(target).attr('id_for');
                 var comments = $('#{0} .inline-comments'.format(boxid));
                 var fn_display = function(idx){
                    $(this).css('display', show);
                 };
                 $(comments).each(fn_display);
                 var btns = $('#{0} .inline-comments-button'.format(boxid));
                 $(btns).each(fn_display);
             });
 
             var commentTotals = {};
             $.each(file_comments, function(i, comment) {
                 var path = $(comment).attr('path');
                 var comms = $(comment).children().length;
                 if (path in commentTotals) {
                     commentTotals[path] += comms;
                 } else {
                     commentTotals[path] = comms;
                 }
             });
             $.each(commentTotals, function(path, total) {
                 var elem = $('.comment-bubble[data-path="'+ path +'"]')
                 elem.css('visibility', 'visible');
                 elem.html(elem.html() + ' ' + total );
             });
 
             $('#merge_pull_request_form').submit(function() {
                 if (!$('#merge_pull_request').attr('disabled')) {
                     $('#merge_pull_request').attr('disabled', 'disabled');
                 }
                 return true;
             });
 
             $('#update_pull_request').on('click', function(e){
                 updateReviewers(undefined, "rhodecode-momentum", "720");
             });
 
             $('#update_commits').on('click', function(e){
                 updateCommits("rhodecode-momentum", "720");
             });
 
         })
       </script>
 
   </div>
 </div></div>
 
 </div>
 
 
 </%def>

rhodecode/templates/ejs_templates/templates.html

@@ -1,242 +1,249 b''
 <%text>
 <div style="display: none">
 
 <script>
 var CG = new ColorGenerator();
 </script>
 
 <script id="ejs_gravatarWithUser" type="text/template" class="ejsTemplate">
 
 <%
 if (size > 16) {
     var gravatar_class = 'gravatar gravatar-large';
 } else {
     var gravatar_class = 'gravatar';
 }
 
 if (tooltip) {
     var gravatar_class = gravatar_class + ' tooltip-hovercard';
 }
 
 var data_hovercard_alt = username;
 
 %>
 
 <%
 if (show_disabled) {
     var user_cls = 'user user-disabled';
 } else {
     var user_cls = 'user';
 }
 var data_hovercard_url = pyroutes.url('hovercard_user', {"user_id": user_id})
 %>
 
 <div class="rc-user">
     <img class="<%= gravatar_class %>" height="<%= size %>" width="<%= size %>" data-hovercard-url="<%= data_hovercard_url %>" data-hovercard-alt="<%= data_hovercard_alt %>" src="<%- gravatar_url -%>">
     <span class="<%= user_cls %>"> <%- user_link -%> </span>
 </div>
 
 </script>
 
 <script id="ejs_reviewMemberEntry" type="text/template" class="ejsTemplate">
     <%
         if (create) {
             var edit_visibility = 'visible';
         } else {
             var edit_visibility = 'hidden';
         }
 
         if (member.user_group && member.user_group.vote_rule) {
             var reviewGroup = '<i class="icon-user-group"></i>';
             var reviewGroupColor = CG.asRGB(CG.getColor(member.user_group.vote_rule));
         } else {
             var reviewGroup = null;
             var reviewGroupColor = 'transparent';
         }
         var rule_show = rule_show || false;
 
         if (rule_show) {
             var rule_visibility = 'table-cell';
         } else {
             var rule_visibility = 'none';
         }
 
     %>
 
 <tr id="reviewer_<%= member.user_id %>" class="reviewer_entry" tooltip="Review Group" data-reviewer-user-id="<%= member.user_id %>">
 
     <td style="width: 20px">
+        <div class="tooltip presence-state" style="display: none; position: absolute; left: 2px" title="This users is currently at this page">
+          <i class="icon-eye" style="color: #0ac878"></i>
+        </div>
+        <% if (role === 'reviewer') { %>
         <div class="reviewer_status tooltip" title="<%= review_status_label %>">
           <i class="icon-circle review-status-<%= review_status %>"></i>
         </div>
+        <% }  else if (role === 'observer') { %>
+        <div class="tooltip" title="Observer without voting right.">
+        <i class="icon-circle-thin"></i>
+        </div>
+        <% } %>
     </td>
 
     <td>
       <div id="reviewer_<%= member.user_id %>_name" class="reviewer_name">
         <%-
           renderTemplate('gravatarWithUser', {
             'size': 16,
             'show_disabled': false,
             'tooltip': true,
             'username': member.username,
             'user_id': member.user_id,
             'user_link': member.user_link,
             'gravatar_url':  member.gravatar_link
             })
         %>
-        <span class="tooltip presence-state" style="display: none" title="This users is currently at this page">
-          <i class="icon-eye" style="color: #0ac878"></i>
-        </span>
       </div>
     </td>
 
     <td style="width: 10px">
     <% if (reviewGroup !== null) { %>
         <span class="tooltip" title="Member of review group from rule: `<%= member.user_group.name %>`" style="color: <%= reviewGroupColor %>">
         <%- reviewGroup %>
         </span>
     <% } %>
     </td>
 
     <% if (mandatory) { %>
     <td style="text-align: right;width: 10px;">
         <div class="reviewer_member_mandatory tooltip" title="Mandatory reviewer">
             <i class="icon-lock"></i>
         </div>
     </td>
 
     <% } else { %>
     <td style="text-align: right;width: 10px;">
         <% if (allowed_to_update) { %>
-          <div class="reviewer_member_remove" onclick="reviewersController.removeReviewMember(<%= member.user_id %>, true)" style="visibility: <%= edit_visibility %>;">
+          <div class="<%=role %>_member_remove" onclick="reviewersController.removeMember(<%= member.user_id %>, true)" style="visibility: <%= edit_visibility %>;">
               <i class="icon-remove"></i>
           </div>
         <% } %>
     </td>
     <% } %>
 
 </tr>
 
-<tr>
+<tr id="reviewer_<%= member.user_id %>_rules">
     <td colspan="4" style="display: <%= rule_visibility %>" class="pr-user-rule-container">
       <input type="hidden" name="__start__" value="reviewer:mapping">
 
         <%if (member.user_group && member.user_group.vote_rule) { %>
             <div class="reviewer_reason">
 
               <%if (member.user_group.vote_rule == -1) {%>
                - group votes required: ALL
               <%} else {%>
                - group votes required: <%= member.user_group.vote_rule %>
               <%}%>
             </div>
         <%} %>
 
         <input type="hidden" name="__start__" value="reasons:sequence">
           <% for (var i = 0; i < reasons.length; i++) { %>
               <% var reason = reasons[i] %>
               <div class="reviewer_reason">- <%= reason %></div>
               <input type="hidden" name="reason" value="<%= reason %>">
           <% } %>
           <input type="hidden" name="__end__" value="reasons:sequence">
 
           <input type="hidden" name="__start__" value="rules:sequence">
           <% for (var i = 0; i < member.rules.length; i++) { %>
               <% var rule = member.rules[i] %>
               <input type="hidden" name="rule_id" value="<%= rule %>">
           <% } %>
           <input type="hidden" name="__end__" value="rules:sequence">
 
           <input id="reviewer_<%= member.user_id %>_input" type="hidden" value="<%= member.user_id %>" name="user_id" />
           <input type="hidden" name="mandatory" value="<%= mandatory %>"/>
+          <input type="hidden" name="role" value="<%= role %>"/>
 
       <input type="hidden" name="__end__" value="reviewer:mapping">
     </td>
 </tr>
 
 </script>
 
 <script id="ejs_commentVersion" type="text/template" class="ejsTemplate">
 
 <%
 if (size > 16) {
     var gravatar_class = 'gravatar gravatar-large';
 } else {
     var gravatar_class = 'gravatar';
 }
 
 %>
 
 <%
 if (show_disabled) {
     var user_cls = 'user user-disabled';
 } else {
     var user_cls = 'user';
 }
 
 %>
 
 <div style='line-height: 20px'>
     <img style="margin: -3px 0" class="<%= gravatar_class %>" height="<%= size %>" width="<%= size %>" src="<%- gravatar_url -%>">
     <strong><%- user_name -%></strong>, <code>v<%- version -%></code> edited <%- timeago_component -%>
 </div>
 
 </script>
 
 
 <script id="ejs_sideBarCommentHovercard" type="text/template" class="ejsTemplate">
 
 <div>
     <% if (is_todo) { %>
         <% if (inline) { %>
             <strong>Inline</strong> TODO on line: <%= line_no %>
             <% if (version_info) { %>
                 <%= version_info %>
             <% } %>
             <br/>
             File: <code><%- file_name -%></code>
         <% } else { %>
             <% if (review_status) { %>
                 <i class="icon-circle review-status-<%= review_status %>"></i>
             <% } %>
             <strong>General</strong> TODO
             <% if (version_info) { %>
                 <%= version_info %>
             <% } %>
         <% } %>
     <% } else { %>
         <% if (inline) { %>
             <strong>Inline</strong> comment on line: <%= line_no %>
             <% if (version_info) { %>
                 <%= version_info %>
             <% } %>
             <br/>
             File: <code><%- file_name -%></code>
         <% } else { %>
             <% if (review_status) { %>
                 <i class="icon-circle review-status-<%= review_status %>"></i>
             <% } %>
             <strong>General</strong> comment
             <% if (version_info) { %>
                 <%= version_info %>
             <% } %>
         <% } %>
     <% } %>
     <br/>
     Created:
     <time class="timeago" title="<%= created_on %>" datetime="<%= datetime %>"><%= $.timeago(datetime) %></time>
 
 </div>
 
 </script>
 
 ##// END OF EJS Templates
 </div>
 
 
 <script>
     // registers the templates into global cache
     registerTemplates();
 </script>
 
 </%text>

rhodecode/templates/email_templates/pull_request_review.mako

@@ -1,146 +1,154 b''
 ## -*- coding: utf-8 -*-
 <%inherit file="base.mako"/>
 <%namespace name="base" file="base.mako"/>
 
 ## EMAIL SUBJECT
 <%def name="subject()" filter="n,trim,whitespace_filter">
 <%
 data = {
     'user': '@'+h.person(user),
     'pr_id': pull_request.pull_request_id,
     'pr_title': pull_request.title,
 }
 
-subject_template = email_pr_review_subject_template or _('{user} requested a pull request review. !{pr_id}: "{pr_title}"')
+if user_role == 'observer':
+    subject_template = email_pr_review_subject_template or _('{user} added you as observer to pull request. !{pr_id}: "{pr_title}"')
+else:
+    subject_template = email_pr_review_subject_template or _('{user} requested a pull request review. !{pr_id}: "{pr_title}"')
 %>
 
 ${subject_template.format(**data) |n}
 </%def>
 
 ## PLAINTEXT VERSION OF BODY
 <%def name="body_plaintext()" filter="n,trim">
 <%
 data = {
     'user': h.person(user),
     'pr_id': pull_request.pull_request_id,
     'pr_title': pull_request.title,
     'source_ref_type': pull_request.source_ref_parts.type,
     'source_ref_name': pull_request.source_ref_parts.name,
     'target_ref_type': pull_request.target_ref_parts.type,
     'target_ref_name': pull_request.target_ref_parts.name,
     'repo_url': pull_request_source_repo_url,
     'source_repo': pull_request_source_repo.repo_name,
     'target_repo': pull_request_target_repo.repo_name,
     'source_repo_url': pull_request_source_repo_url,
     'target_repo_url': pull_request_target_repo_url,
 }
+
 %>
 
 * ${_('Pull Request link')}: ${pull_request_url}
 
 * ${h.literal(_('Commit flow: {source_ref_type}:{source_ref_name} of {source_repo_url} into {target_ref_type}:{target_ref_name} of {target_repo_url}').format(**data))}
 
 * ${_('Title')}: ${pull_request.title}
 
 * ${_('Description')}:
 
 ${pull_request.description | trim}
 
 
 * ${_ungettext('Commit (%(num)s)', 'Commits (%(num)s)', len(pull_request_commits) ) % {'num': len(pull_request_commits)}}:
 
 % for commit_id, message in pull_request_commits:
     - ${h.short_id(commit_id)}
-      ${h.chop_at_smart(message, '\n', suffix_if_chopped='...')}
+    ${h.chop_at_smart(message.lstrip(), '\n', suffix_if_chopped='...')}
 
 % endfor
 
 ---
 ${self.plaintext_footer()}
 </%def>
 <%
 data = {
     'user': h.person(user),
     'pr_id': pull_request.pull_request_id,
     'pr_title': pull_request.title,
     'source_ref_type': pull_request.source_ref_parts.type,
     'source_ref_name': pull_request.source_ref_parts.name,
     'target_ref_type': pull_request.target_ref_parts.type,
     'target_ref_name': pull_request.target_ref_parts.name,
     'repo_url': pull_request_source_repo_url,
     'source_repo': pull_request_source_repo.repo_name,
     'target_repo': pull_request_target_repo.repo_name,
     'source_repo_url': h.link_to(pull_request_source_repo.repo_name, pull_request_source_repo_url),
     'target_repo_url': h.link_to(pull_request_target_repo.repo_name, pull_request_target_repo_url),
 }
 %>
 ## header
 <table style="text-align:left;vertical-align:middle;width: 100%">
     <tr>
     <td style="width:100%;border-bottom:1px solid #dbd9da;">
-
         <div style="margin: 0; font-weight: bold">
+            % if user_role == 'observer':
+            <div class="clear-both" class="clear-both" style="margin-bottom: 4px">
+                <span style="color:#7E7F7F">@${h.person(user.username)}</span>
+                ${_('added you as observer to')}
+                <a href="${pull_request_url}" style="${base.link_css()}">pull request</a>.
+            </div>
+            % else:
             <div class="clear-both" class="clear-both" style="margin-bottom: 4px">
                 <span style="color:#7E7F7F">@${h.person(user.username)}</span>
                 ${_('requested a')}
-                <a href="${pull_request_url}" style="${base.link_css()}">
-                ${_('pull request review.').format(**data) }
-                </a>
+                <a href="${pull_request_url}" style="${base.link_css()}">pull request</a> review.
             </div>
+            % endif
             <div style="margin-top: 10px"></div>
             ${_('Pull request')} <code>!${data['pr_id']}: ${data['pr_title']}</code>
         </div>
-
     </td>
     </tr>
 
 </table>
 <div class="clear-both"></div>
 ## main body
 <table style="text-align:left;vertical-align:middle;width: 100%">
     ## spacing def
     <tr>
         <td style="width: 130px"></td>
         <td></td>
     </tr>
 
     <tr>
         <td style="padding-right:20px;">${_('Pull request')}:</td>
         <td>
             <a href="${pull_request_url}" style="${base.link_css()}">
             !${pull_request.pull_request_id}
             </a>
         </td>
     </tr>
 
     <tr>
         <td style="padding-right:20px;line-height:20px;">${_('Commit Flow')}:</td>
         <td style="line-height:20px;">
             <code>${'{}:{}'.format(data['source_ref_type'], pull_request.source_ref_parts.name)}</code> ${_('of')} ${data['source_repo_url']}
             &rarr;
             <code>${'{}:{}'.format(data['target_ref_type'], pull_request.target_ref_parts.name)}</code> ${_('of')}  ${data['target_repo_url']}
         </td>
     </tr>
 
     <tr>
         <td style="padding-right:20px;">${_('Description')}:</td>
         <td style="white-space:pre-wrap"><code>${pull_request.description | trim}</code></td>
     </tr>
     <tr>
         <td style="padding-right:20px;">${_ungettext('Commit (%(num)s)', 'Commits (%(num)s)', len(pull_request_commits)) % {'num': len(pull_request_commits)}}:</td>
         <td></td>
     </tr>
 
     <tr>
         <td colspan="2">
             <ol style="margin:0 0 0 1em;padding:0;text-align:left;">
                 % for commit_id, message in pull_request_commits:
                     <li style="margin:0 0 1em;">
                         <pre style="margin:0 0 .5em"><a href="${h.route_path('repo_commit', repo_name=pull_request_source_repo.repo_name, commit_id=commit_id)}" style="${base.link_css()}">${h.short_id(commit_id)}</a></pre>
                         ${h.chop_at_smart(message, '\n', suffix_if_chopped='...')}
                     </li>
                 % endfor
             </ol>
         </td>
     </tr>
 </table>

rhodecode/templates/pullrequests/pullrequest.mako

@@ -1,555 +1,635 b''
 <%inherit file="/base/base.mako"/>
 <%namespace name="dt" file="/data_table/_dt_elements.mako"/>
 
 <%def name="title()">
     ${c.repo_name} ${_('New pull request')}
 </%def>
 
 <%def name="breadcrumbs_links()"></%def>
 
 <%def name="menu_bar_nav()">
     ${self.menu_items(active='repositories')}
 </%def>
 
 <%def name="menu_bar_subnav()">
     ${self.repo_menu(active='showpullrequest')}
 </%def>
 
 <%def name="main()">
 <div class="box">
     ${h.secure_form(h.route_path('pullrequest_create', repo_name=c.repo_name, _query=request.GET.mixed()), id='pull_request_form', request=request)}
 
         <div class="box">
 
             <div class="summary-details block-left">
 
                 <div class="form" style="padding-top: 10px">
 
                     <div class="fields" >
 
                         ## COMMIT FLOW
                         <div class="field">
                             <div class="label label-textarea">
                                 <label for="commit_flow">${_('Commit flow')}:</label>
                             </div>
 
                             <div class="content">
                                 <div class="flex-container">
                                     <div style="width: 45%;">
                                         <div class="panel panel-default source-panel">
                                             <div class="panel-heading">
                                                 <h3 class="panel-title">${_('Source repository')}</h3>
                                             </div>
                                             <div class="panel-body">
                                                 <div style="display:none">${c.rhodecode_db_repo.description}</div>
                                                 ${h.hidden('source_repo')}
                                                 ${h.hidden('source_ref')}
 
                                                 <div id="pr_open_message"></div>
                                             </div>
                                         </div>
                                     </div>
 
                                     <div style="width: 90px; text-align: center; padding-top: 30px">
                                     <div>
                                         <i class="icon-right" style="font-size: 2.2em"></i>
                                     </div>
                                     <div style="position: relative; top: 10px">
                                     <span class="tag tag">
                                         <span id="switch_base"></span>
                                     </span>
                                     </div>
 
                                 </div>
 
                                     <div style="width: 45%;">
 
                                     <div class="panel panel-default target-panel">
                                         <div class="panel-heading">
                                             <h3 class="panel-title">${_('Target repository')}</h3>
                                         </div>
                                         <div class="panel-body">
                                           <div style="display:none" id="target_repo_desc"></div>
                                           ${h.hidden('target_repo')}
                                           ${h.hidden('target_ref')}
                                           <span id="target_ref_loading" style="display: none">
                                               ${_('Loading refs...')}
                                           </span>
                                         </div>
                                     </div>
 
                                 </div>
                                 </div>
 
                             </div>
 
                         </div>
 
                         ## TITLE
                         <div class="field">
                             <div class="label">
                                 <label for="pullrequest_title">${_('Title')}:</label>
                             </div>
                             <div class="input">
                                 ${h.text('pullrequest_title', c.default_title, class_="medium autogenerated-title")}
                             </div>
                             <p class="help-block">
                                 Start the title with WIP: to prevent accidental merge of Work In Progress pull request before it's ready.
                             </p>
                         </div>
 
                         ## DESC
                         <div class="field">
                             <div class="label label-textarea">
                                 <label for="pullrequest_desc">${_('Description')}:</label>
                             </div>
                             <div class="textarea text-area">
                                 <input id="pr-renderer-input" type="hidden" name="description_renderer" value="${c.visual.default_renderer}">
                                 ${dt.markup_form('pullrequest_desc')}
                             </div>
                         </div>
 
                         ## REVIEWERS
                         <div class="field">
                             <div class="label label-textarea">
-                                <label for="pullrequest_reviewers">${_('Reviewers')}:</label>
+                                <label for="pullrequest_reviewers">${_('Reviewers / Observers')}:</label>
                             </div>
                             <div class="content">
                                 ## REVIEW RULES
                                 <div id="review_rules" style="display: none" class="reviewers-title">
                                     <div class="pr-details-title">
                                         ${_('Reviewer rules')}
                                     </div>
                                     <div class="pr-reviewer-rules">
                                         ## review rules will be appended here, by default reviewers logic
                                     </div>
                                 </div>
 
-                                ## REVIEWERS
+                                ## REVIEWERS / OBSERVERS
                                 <div class="reviewers-title">
-                                    <div class="pr-details-title">
-                                        ${_('Pull request reviewers')}
-                                        <span class="calculate-reviewers"> - ${_('loading...')}</span>
-                                    </div>
-                                </div>
-                                <div id="reviewers" class="pr-details-content reviewers">
-                                    ## members goes here, filled via JS based on initial selection !
-                                    <input type="hidden" name="__start__" value="review_members:sequence">
-                                    <table id="review_members" class="group_members">
-                                    ## This content is loaded via JS and ReviewersPanel
-                                    </table>
-                                    <input type="hidden" name="__end__" value="review_members:sequence">
+
+                                    <ul class="nav-links clearfix">
+
+                                        ## TAB1 MANDATORY REVIEWERS
+                                        <li class="active">
+                                            <a id="reviewers-btn" href="#showReviewers" tabindex="-1">
+                                                Reviewers
+                                                <span id="reviewers-cnt" data-count="0" class="menulink-counter">0</span>
+                                            </a>
+                                        </li>
+
+                                        ## TAB2 OBSERVERS
+                                        <li class="">
+                                            <a id="observers-btn" href="#showObservers" tabindex="-1">
+                                                Observers
+                                                <span id="observers-cnt"  data-count="0" class="menulink-counter">0</span>
+                                            </a>
+                                        </li>
+
+                                    </ul>
 
-                                    <div id="add_reviewer_input" class='ac'>
-                                        <div class="reviewer_ac">
-                                            ${h.text('user', class_='ac-input', placeholder=_('Add reviewer or reviewer group'))}
-                                            <div id="reviewers_container"></div>
+                                    ## TAB1 MANDATORY REVIEWERS
+                                    <div id="reviewers-container">
+                                        <span class="calculate-reviewers">
+                                            <h4>${_('loading...')}</h4>
+                                        </span>
+
+                                        <div id="reviewers" class="pr-details-content reviewers">
+                                            ## members goes here, filled via JS based on initial selection !
+                                            <input type="hidden" name="__start__" value="review_members:sequence">
+                                            <table id="review_members" class="group_members">
+                                            ## This content is loaded via JS and ReviewersPanel, an sets reviewer_entry class on each element
+                                            </table>
+                                            <input type="hidden" name="__end__" value="review_members:sequence">
+
+                                            <div id="add_reviewer_input" class='ac'>
+                                                <div class="reviewer_ac">
+                                                    ${h.text('user', class_='ac-input', placeholder=_('Add reviewer or reviewer group'))}
+                                                    <div id="reviewers_container"></div>
+                                                </div>
+                                            </div>
+
                                         </div>
                                     </div>
 
+                                    ## TAB2 OBSERVERS
+                                    <div id="observers-container" style="display: none">
+                                        <span class="calculate-reviewers">
+                                            <h4>${_('loading...')}</h4>
+                                        </span>
+
+                                        <div id="observers" class="pr-details-content observers">
+                                            ## members goes here, filled via JS based on initial selection !
+                                            <input type="hidden" name="__start__" value="observer_members:sequence">
+                                            <table id="observer_members" class="group_members">
+                                            ## This content is loaded via JS and ReviewersPanel, an sets reviewer_entry class on each element
+                                            </table>
+                                            <input type="hidden" name="__end__" value="observer_members:sequence">
+
+                                            <div id="add_observer_input" class='ac'>
+                                                <div class="observer_ac">
+                                                    ${h.text('observer', class_='ac-input', placeholder=_('Add observer or observer group'))}
+                                                    <div id="observers_container"></div>
+                                                </div>
+                                            </div>
+                                        </div>
+
+                                    </div>
+
                                 </div>
+
                             </div>
                         </div>
 
                         ## SUBMIT
                         <div class="field">
                             <div class="label label-textarea">
                                 <label for="pullrequest_submit"></label>
                             </div>
                             <div class="input">
                                 <div class="pr-submit-button">
                                     <input id="pr_submit" class="btn" name="save" type="submit" value="${_('Submit Pull Request')}">
                                 </div>
                             </div>
                         </div>
                     </div>
                 </div>
             </div>
 
         </div>
 
     ${h.end_form()}
 </div>
 
 <script type="text/javascript">
  $(function(){
    var defaultSourceRepo = '${c.default_repo_data['source_repo_name']}';
    var defaultSourceRepoData = ${c.default_repo_data['source_refs_json']|n};
    var defaultTargetRepo = '${c.default_repo_data['target_repo_name']}';
    var defaultTargetRepoData = ${c.default_repo_data['target_refs_json']|n};
 
    var $pullRequestForm = $('#pull_request_form');
    var $pullRequestSubmit = $('#pr_submit', $pullRequestForm);
    var $sourceRepo = $('#source_repo', $pullRequestForm);
    var $targetRepo = $('#target_repo', $pullRequestForm);
    var $sourceRef = $('#source_ref', $pullRequestForm);
    var $targetRef = $('#target_ref', $pullRequestForm);
 
    var sourceRepo = function() { return $sourceRepo.eq(0).val() };
    var sourceRef = function() { return $sourceRef.eq(0).val().split(':') };
 
    var targetRepo = function() { return $targetRepo.eq(0).val() };
    var targetRef = function() { return $targetRef.eq(0).val().split(':') };
 
    var calculateContainerWidth = function() {
        var maxWidth = 0;
        var repoSelect2Containers = ['#source_repo', '#target_repo'];
        $.each(repoSelect2Containers, function(idx, value) {
            $(value).select2('container').width('auto');
            var curWidth = $(value).select2('container').width();
            if (maxWidth <= curWidth) {
                maxWidth = curWidth;
            }
            $.each(repoSelect2Containers, function(idx, value) {
                $(value).select2('container').width(maxWidth + 10);
            });
        });
    };
 
    var initRefSelection = function(selectedRef) {
        return function(element, callback) {
            // translate our select2 id into a text, it's a mapping to show
            // simple label when selecting by internal ID.
            var id, refData;
            if (selectedRef === undefined || selectedRef === null) {
              id = element.val();
              refData = element.val().split(':');
 
              if (refData.length !== 3){
                  refData = ["", "", ""]
              }
            } else {
              id = selectedRef;
              refData = selectedRef.split(':');
            }
 
            var text = refData[1];
            if (refData[0] === 'rev') {
                text = text.substring(0, 12);
            }
 
            var data = {id: id, text: text};
            callback(data);
        };
    };
 
    var formatRefSelection = function(data, container, escapeMarkup) {
        var prefix = '';
        var refData = data.id.split(':');
        if (refData[0] === 'branch') {
            prefix = '<i class="icon-branch"></i>';
        }
        else if (refData[0] === 'book') {
            prefix = '<i class="icon-bookmark"></i>';
        }
        else if (refData[0] === 'tag') {
            prefix = '<i class="icon-tag"></i>';
        }
 
        var originalOption = data.element;
        return prefix + escapeMarkup(data.text);
    };formatSelection:
 
    // custom code mirror
    var codeMirrorInstance = $('#pullrequest_desc').get(0).MarkupForm.cm;
 
    var diffDataHandler = function(data) {
 
        var commitElements = data['commits'];
        var files = data['files'];
        var added = data['stats'][0]
        var deleted = data['stats'][1]
        var commonAncestorId = data['ancestor'];
        var _sourceRefType = sourceRef()[0];
        var _sourceRefName = sourceRef()[1];
        var prTitleAndDesc = getTitleAndDescription(_sourceRefType, _sourceRefName, commitElements, 5);
 
        var title = prTitleAndDesc[0];
        var proposedDescription = prTitleAndDesc[1];
 
        var useGeneratedTitle = (
             $('#pullrequest_title').hasClass('autogenerated-title') ||
             $('#pullrequest_title').val() === "");
 
        if (title && useGeneratedTitle) {
            // use generated title if we haven't specified our own
            $('#pullrequest_title').val(title);
            $('#pullrequest_title').addClass('autogenerated-title');
 
        }
 
        var useGeneratedDescription = (
            !codeMirrorInstance._userDefinedValue ||
             codeMirrorInstance.getValue() === "");
 
        if (proposedDescription && useGeneratedDescription) {
             // set proposed content, if we haven't defined our own,
             // or we don't have description written
             codeMirrorInstance._userDefinedValue = false; // reset state
             codeMirrorInstance.setValue(proposedDescription);
        }
 
        // refresh our codeMirror so events kicks in and it's change aware
        codeMirrorInstance.refresh();
 
        var url_data = {
            'repo_name': targetRepo(),
            'target_repo': sourceRepo(),
            'source_ref': targetRef()[2],
            'source_ref_type': 'rev',
            'target_ref': sourceRef()[2],
            'target_ref_type': 'rev',
            'merge': true,
            '_': Date.now() // bypass browser caching
        }; // gather the source/target ref and repo here
        var url = pyroutes.url('repo_compare', url_data);
 
        var msg = '<input id="common_ancestor" type="hidden" name="common_ancestor" value="{0}">'.format(commonAncestorId);
        msg += '<input type="hidden" name="__start__" value="revisions:sequence">'
 
        $.each(commitElements, function(idx, value) {
            msg += '<input type="hidden" name="revisions" value="{0}">'.format(value["raw_id"]);
        });
 
        msg += '<input type="hidden" name="__end__" value="revisions:sequence">'
        msg += _ngettext(
            'Compare summary: <strong>{0} commit</strong>',
            'Compare summary: <strong>{0} commits</strong>',
            commitElements.length).format(commitElements.length)
 
        msg += '';
        msg += _ngettext(
            '<strong>, and {0} file</strong> changed.',
            '<strong>, and {0} files</strong> changed.',
            files.length).format(files.length)
 
        msg += '\n Diff: <span class="op-added">{0} lines inserted</span>, <span class="op-deleted">{1} lines deleted </span>.'.format(added, deleted)
 
        msg += '\n <a class="" id="pull_request_overview_url" href="{0}" target="_blank">${_('Show detailed compare.')}</a>'.format(url);
 
        if (commitElements.length) {
            var commitsLink = '<a href="#pull_request_overview"><strong>{0}</strong></a>'.format(commitElements.length);
            prButtonLock(false, msg.replace('__COMMITS__', commitsLink), 'compare');
        }
        else {
            var noCommitsMsg = '<span class="alert-text-warning">{0}</span>'.format(
                _gettext('There are no commits to merge.'));
            prButtonLock(true, noCommitsMsg, 'compare');
        }
 
        //make both panels equal
        $('.target-panel').height($('.source-panel').height())
-
    };
 
    reviewersController = new ReviewersController();
    reviewersController.diffDataHandler = diffDataHandler;
 
    var queryTargetRepo = function(self, query) {
        // cache ALL results if query is empty
        var cacheKey = query.term || '__';
        var cachedData = self.cachedDataSource[cacheKey];
 
        if (cachedData) {
            query.callback({results: cachedData.results});
        } else {
            $.ajax({
                url: pyroutes.url('pullrequest_repo_targets', {'repo_name': templateContext.repo_name}),
                data: {query: query.term},
                dataType: 'json',
                type: 'GET',
                success: function(data) {
                    self.cachedDataSource[cacheKey] = data;
                    query.callback({results: data.results});
                },
                error: function(jqXHR, textStatus, errorThrown) {
                 var prefix = "Error while fetching entries.\n"
                 var message = formatErrorMessage(jqXHR, textStatus, errorThrown, prefix);
                 ajaxErrorSwal(message);
                }
            });
        }
    };
 
    var queryTargetRefs = function(initialData, query) {
        var data = {results: []};
        // filter initialData
        $.each(initialData, function() {
            var section = this.text;
            var children = [];
            $.each(this.children, function() {
                if (query.term.length === 0 ||
                    this.text.toUpperCase().indexOf(query.term.toUpperCase()) >= 0 ) {
                    children.push({'id': this.id, 'text': this.text})
                }
            });
            data.results.push({'text': section, 'children': children})
        });
        query.callback({results: data.results});
    };
 
    var Select2Box = function(element, overrides) {
      var globalDefaults = {
          dropdownAutoWidth: true,
          containerCssClass: "drop-menu",
          dropdownCssClass: "drop-menu-dropdown"
      };
 
      var initSelect2 = function(defaultOptions) {
        var options = jQuery.extend(globalDefaults, defaultOptions, overrides);
        element.select2(options);
      };
 
      return {
        initRef: function() {
          var defaultOptions = {
            minimumResultsForSearch: 5,
            formatSelection: formatRefSelection
          };
 
          initSelect2(defaultOptions);
        },
 
        initRepo: function(defaultValue, readOnly) {
          var defaultOptions = {
            initSelection : function (element, callback) {
              var data = {id: defaultValue, text: defaultValue};
              callback(data);
            }
          };
 
          initSelect2(defaultOptions);
 
          element.select2('val', defaultSourceRepo);
          if (readOnly === true) {
            element.select2('readonly', true);
          }
        }
      };
    };
 
    var initTargetRefs = function(refsData, selectedRef) {
 
      Select2Box($targetRef, {
          placeholder: "${_('Select commit reference')}",
        query: function(query) {
          queryTargetRefs(refsData, query);
        },
        initSelection : initRefSelection(selectedRef)
      }).initRef();
 
      if (!(selectedRef === undefined)) {
          $targetRef.select2('val', selectedRef);
      }
    };
 
    var targetRepoChanged = function(repoData) {
        // generate new DESC of target repo displayed next to select
 
        $('#target_repo_desc').html(repoData['description']);
 
        var prLink = pyroutes.url('pullrequest_new', {'repo_name': repoData['name']});
        var title = _gettext('Switch target repository with the source.')
        $('#switch_base').html("<a class=\"tooltip\" title=\"{0}\" href=\"{1}\">Switch sides</a>".format(title, prLink))
 
        // generate dynamic select2 for refs.
        initTargetRefs(repoData['refs']['select2_refs'],
                       repoData['refs']['selected_ref']);
 
    };
 
    var sourceRefSelect2 = Select2Box($sourceRef, {
        placeholder: "${_('Select commit reference')}",
        query: function(query) {
          var initialData = defaultSourceRepoData['refs']['select2_refs'];
          queryTargetRefs(initialData, query)
        },
        initSelection: initRefSelection()
-     }
-   );
+   });
 
    var sourceRepoSelect2 = Select2Box($sourceRepo, {
      query: function(query) {}
    });
 
    var targetRepoSelect2 = Select2Box($targetRepo, {
      cachedDataSource: {},
      query: $.debounce(250, function(query) {
        queryTargetRepo(this, query);
      }),
      formatResult: formatRepoResult
    });
 
    sourceRefSelect2.initRef();
 
    sourceRepoSelect2.initRepo(defaultSourceRepo, true);
 
    targetRepoSelect2.initRepo(defaultTargetRepo, false);
 
    $sourceRef.on('change', function(e){
      reviewersController.loadDefaultReviewers(
          sourceRepo(), sourceRef(), targetRepo(), targetRef());
    });
 
    $targetRef.on('change', function(e){
      reviewersController.loadDefaultReviewers(
          sourceRepo(), sourceRef(), targetRepo(), targetRef());
    });
 
    $targetRepo.on('change', function(e){
        var repoName = $(this).val();
        calculateContainerWidth();
        $targetRef.select2('destroy');
        $('#target_ref_loading').show();
 
        $.ajax({
            url: pyroutes.url('pullrequest_repo_refs',
              {'repo_name': templateContext.repo_name, 'target_repo_name':repoName}),
            data: {},
            dataType: 'json',
            type: 'GET',
            success: function(data) {
                $('#target_ref_loading').hide();
                targetRepoChanged(data);
            },
            error: function(jqXHR, textStatus, errorThrown) {
                 var prefix = "Error while fetching entries.\n"
                 var message = formatErrorMessage(jqXHR, textStatus, errorThrown, prefix);
                 ajaxErrorSwal(message);
            }
        })
 
    });
 
-    $pullRequestForm.on('submit', function(e){
-        // Flush changes into textarea
-        codeMirrorInstance.save();
-        prButtonLock(true, null, 'all');
-        $pullRequestSubmit.val(_gettext('Please wait creating pull request...'));
-    });
+   $pullRequestForm.on('submit', function(e){
+       // Flush changes into textarea
+       codeMirrorInstance.save();
+       prButtonLock(true, null, 'all');
+       $pullRequestSubmit.val(_gettext('Please wait creating pull request...'));
+   });
 
    prButtonLock(true, "${_('Please select source and target')}", 'all');
 
    // auto-load on init, the target refs select2
    calculateContainerWidth();
    targetRepoChanged(defaultTargetRepoData);
 
    $('#pullrequest_title').on('keyup', function(e){
        $(this).removeClass('autogenerated-title');
    });
 
    % if c.default_source_ref:
    // in case we have a pre-selected value, use it now
    $sourceRef.select2('val', '${c.default_source_ref}');
 
 
-   // default reviewers
+   // default reviewers / observers
    reviewersController.loadDefaultReviewers(
        sourceRepo(), sourceRef(), targetRepo(), targetRef());
    % endif
 
-   ReviewerAutoComplete('#user');
+   ReviewerAutoComplete('#user', reviewersController);
+   ObserverAutoComplete('#observer', reviewersController);
+
+   // TODO, move this to another handler
+
+   var $reviewersBtn = $('#reviewers-btn');
+   var $reviewersContainer = $('#reviewers-container');
+
+   var $observersBtn = $('#observers-btn')
+   var $observersContainer = $('#observers-container');
+
+   $reviewersBtn.on('click', function (e) {
+
+       $observersContainer.hide();
+       $reviewersContainer.show();
+
+       $observersBtn.parent().removeClass('active');
+       $reviewersBtn.parent().addClass('active');
+       e.preventDefault();
+
+   })
+
+   $observersBtn.on('click', function (e) {
+
+       $reviewersContainer.hide();
+       $observersContainer.show();
+
+       $reviewersBtn.parent().removeClass('active');
+       $observersBtn.parent().addClass('active');
+       e.preventDefault();
+
+   })
+
  });
 </script>
 
 </%def>

rhodecode/templates/pullrequests/pullrequest_show.mako

@@ -1,993 +1,994 b''
 <%inherit file="/base/base.mako"/>
 <%namespace name="base" file="/base/base.mako"/>
 <%namespace name="dt" file="/data_table/_dt_elements.mako"/>
 <%namespace name="sidebar" file="/base/sidebar.mako"/>
 
 
 <%def name="title()">
     ${_('{} Pull Request !{}').format(c.repo_name, c.pull_request.pull_request_id)}
     %if c.rhodecode_name:
         &middot; ${h.branding(c.rhodecode_name)}
     %endif
 </%def>
 
 <%def name="breadcrumbs_links()">
 
 </%def>
 
 <%def name="menu_bar_nav()">
     ${self.menu_items(active='repositories')}
 </%def>
 
 <%def name="menu_bar_subnav()">
     ${self.repo_menu(active='showpullrequest')}
 </%def>
 
 
 <%def name="main()">
 ## Container to gather extracted Tickets
 <%
     c.referenced_commit_issues = []
     c.referenced_desc_issues = []
 %>
 
 <script type="text/javascript">
     // TODO: marcink switch this to pyroutes
     AJAX_COMMENT_DELETE_URL = "${h.route_path('pullrequest_comment_delete',repo_name=c.repo_name,pull_request_id=c.pull_request.pull_request_id,comment_id='__COMMENT_ID__')}";
     templateContext.pull_request_data.pull_request_id = ${c.pull_request.pull_request_id};
     templateContext.pull_request_data.pull_request_version = '${request.GET.get('version', '')}';
 </script>
 
 <div class="box">
 
   <div class="box pr-summary">
 
     <div class="summary-details block-left">
         <div id="pr-title">
             % if c.pull_request.is_closed():
                 <span class="pr-title-closed-tag tag">${_('Closed')}</span>
             % endif
             <input class="pr-title-input large disabled" disabled="disabled" name="pullrequest_title" type="text" value="${c.pull_request.title}">
         </div>
         <div id="pr-title-edit" class="input" style="display: none;">
             <input class="pr-title-input large" id="pr-title-input" name="pullrequest_title" type="text" value="${c.pull_request.title}">
         </div>
 
     <% summary = lambda n:{False:'summary-short'}.get(n) %>
     <div class="pr-details-title">
         <div class="pull-left">
             <a href="${h.route_path('pull_requests_global', pull_request_id=c.pull_request.pull_request_id)}">${_('Pull request !{}').format(c.pull_request.pull_request_id)}</a>
             ${_('Created on')}
             <span class="tooltip" title="${_('Last updated on')} ${h.format_date(c.pull_request.updated_on)}">${h.format_date(c.pull_request.created_on)},</span>
             <span class="pr-details-title-author-pref">${_('by')}</span>
         </div>
 
         <div class="pull-left">
             ${self.gravatar_with_user(c.pull_request.author.email, 16, tooltip=True)}
         </div>
 
         %if c.allowed_to_update:
           <div class="pull-right">
               <div id="edit_pull_request" class="action_button pr-save" style="display: none;">${_('Update title & description')}</div>
               <div id="delete_pullrequest" class="action_button pr-save ${('' if c.allowed_to_delete else 'disabled' )}" style="display: none;">
                   % if c.allowed_to_delete:
                       ${h.secure_form(h.route_path('pullrequest_delete', repo_name=c.pull_request.target_repo.repo_name, pull_request_id=c.pull_request.pull_request_id), request=request)}
                           <input class="btn btn-link btn-danger no-margin" id="remove_${c.pull_request.pull_request_id}" name="remove_${c.pull_request.pull_request_id}"
                                  onclick="submitConfirm(event, this, _gettext('Confirm to delete this pull request'), _gettext('Delete'), '${'!{}'.format(c.pull_request.pull_request_id)}')"
                                  type="submit" value="${_('Delete pull request')}">
                       ${h.end_form()}
                   % else:
                     <span class="tooltip" title="${_('Not allowed to delete this pull request')}">${_('Delete pull request')}</span>
                   % endif
               </div>
               <div id="open_edit_pullrequest" class="action_button">${_('Edit')}</div>
               <div id="close_edit_pullrequest" class="action_button" style="display: none;">${_('Cancel')}</div>
           </div>
 
         %endif
     </div>
 
     <div id="pr-desc" class="input" title="${_('Rendered using {} renderer').format(c.renderer)}">
         ${h.render(c.pull_request.description, renderer=c.renderer, repo_name=c.repo_name, issues_container=c.referenced_desc_issues)}
     </div>
 
     <div id="pr-desc-edit" class="input textarea" style="display: none;">
         <input id="pr-renderer-input" type="hidden" name="description_renderer" value="${c.visual.default_renderer}">
         ${dt.markup_form('pr-description-input', form_text=c.pull_request.description)}
     </div>
 
     <div id="summary" class="fields pr-details-content">
 
        ## source
        <div class="field">
         <div class="label-pr-detail">
             <label>${_('Commit flow')}:</label>
         </div>
         <div class="input">
             <div class="pr-commit-flow">
                 ## Source
                 %if c.pull_request.source_ref_parts.type == 'branch':
                     <a href="${h.route_path('repo_commits', repo_name=c.pull_request.source_repo.repo_name, _query=dict(branch=c.pull_request.source_ref_parts.name))}"><code class="pr-source-info">${c.pull_request.source_ref_parts.type}:${c.pull_request.source_ref_parts.name}</code></a>
                 %else:
                     <code class="pr-source-info">${'{}:{}'.format(c.pull_request.source_ref_parts.type, c.pull_request.source_ref_parts.name)}</code>
                 %endif
                 ${_('of')} <a href="${h.route_path('repo_summary', repo_name=c.pull_request.source_repo.repo_name)}">${c.pull_request.source_repo.repo_name}</a>
                 &rarr;
                 ## Target
                 %if c.pull_request.target_ref_parts.type == 'branch':
                     <a href="${h.route_path('repo_commits', repo_name=c.pull_request.target_repo.repo_name, _query=dict(branch=c.pull_request.target_ref_parts.name))}"><code class="pr-target-info">${c.pull_request.target_ref_parts.type}:${c.pull_request.target_ref_parts.name}</code></a>
                 %else:
                     <code class="pr-target-info">${'{}:{}'.format(c.pull_request.target_ref_parts.type, c.pull_request.target_ref_parts.name)}</code>
                 %endif
 
                 ${_('of')} <a href="${h.route_path('repo_summary', repo_name=c.pull_request.target_repo.repo_name)}">${c.pull_request.target_repo.repo_name}</a>
 
                 <a class="source-details-action" href="#expand-source-details" onclick="return toggleElement(this, '.source-details')" data-toggle-on='<i class="icon-angle-down">more details</i>' data-toggle-off='<i class="icon-angle-up">less details</i>'>
                     <i class="icon-angle-down">more details</i>
                 </a>
 
             </div>
 
             <div class="source-details" style="display: none">
 
                 <ul>
 
                     ## common ancestor
                     <li>
                         ${_('Common ancestor')}:
                         % if c.ancestor_commit:
                             <a href="${h.route_path('repo_commit', repo_name=c.target_repo.repo_name, commit_id=c.ancestor_commit.raw_id)}">${h.show_id(c.ancestor_commit)}</a>
                         % else:
                             ${_('not available')}
                         % endif
                     </li>
 
                     ## pull url
                     <li>
                         %if h.is_hg(c.pull_request.source_repo):
                             <% clone_url = 'hg pull -r {} {}'.format(h.short_id(c.source_ref), c.pull_request.source_repo.clone_url()) %>
                         %elif h.is_git(c.pull_request.source_repo):
                             <% clone_url = 'git pull {} {}'.format(c.pull_request.source_repo.clone_url(), c.pull_request.source_ref_parts.name) %>
                         %endif
 
                         <span>${_('Pull changes from source')}</span>: <input type="text" class="input-monospace pr-pullinfo" value="${clone_url}" readonly="readonly">
                         <i class="tooltip icon-clipboard clipboard-action pull-right pr-pullinfo-copy" data-clipboard-text="${clone_url}" title="${_('Copy the pull url')}"></i>
                     </li>
 
                     ## Shadow repo
                     <li>
                         % if not c.pull_request.is_closed() and c.pull_request.shadow_merge_ref:
                             %if h.is_hg(c.pull_request.target_repo):
                                 <% clone_url = 'hg clone --update {} {} pull-request-{}'.format(c.pull_request.shadow_merge_ref.name, c.shadow_clone_url, c.pull_request.pull_request_id) %>
                             %elif h.is_git(c.pull_request.target_repo):
                                 <% clone_url = 'git clone --branch {} {} pull-request-{}'.format(c.pull_request.shadow_merge_ref.name, c.shadow_clone_url, c.pull_request.pull_request_id) %>
                             %endif
 
                             <span class="tooltip" title="${_('Clone repository in its merged state using shadow repository')}">${_('Clone from shadow repository')}</span>: <input type="text" class="input-monospace pr-mergeinfo" value="${clone_url}" readonly="readonly">
                             <i class="tooltip icon-clipboard clipboard-action pull-right pr-mergeinfo-copy" data-clipboard-text="${clone_url}" title="${_('Copy the clone url')}"></i>
 
                         % else:
                             <div class="">
                                 ${_('Shadow repository data not available')}.
                             </div>
                         % endif
                     </li>
 
                 </ul>
 
             </div>
 
         </div>
 
        </div>
 
        ## versions
        <div class="field">
            <div class="label-pr-detail">
                <label>${_('Versions')}:</label>
            </div>
 
            <% outdated_comm_count_ver = len(c.inline_versions[None]['outdated']) %>
            <% general_outdated_comm_count_ver = len(c.comment_versions[None]['outdated']) %>
 
            <div class="pr-versions">
            % if c.show_version_changes:
                <% outdated_comm_count_ver = len(c.inline_versions[c.at_version_num]['outdated']) %>
                <% general_outdated_comm_count_ver = len(c.comment_versions[c.at_version_num]['outdated']) %>
                ${_ungettext('{} version available for this pull request, ', '{} versions available for this pull request, ', len(c.versions)).format(len(c.versions))}
                <a id="show-pr-versions" onclick="return versionController.toggleVersionView(this)" href="#show-pr-versions"
                     data-toggle-on="${_('show versions')}."
                     data-toggle-off="${_('hide versions')}.">
                     ${_('show versions')}.
                </a>
                <table>
                    ## SHOW ALL VERSIONS OF PR
                    <% ver_pr = None %>
 
                    % for data in reversed(list(enumerate(c.versions, 1))):
                        <% ver_pos = data[0] %>
                        <% ver = data[1] %>
                        <% ver_pr = ver.pull_request_version_id %>
                        <% display_row = '' if c.at_version and (c.at_version_num == ver_pr or c.from_version_num == ver_pr) else 'none' %>
 
                        <tr class="version-pr" style="display: ${display_row}">
                            <td>
                                 <code>
                                     <a href="${request.current_route_path(_query=dict(version=ver_pr or 'latest'))}">v${ver_pos}</a>
                                 </code>
                            </td>
                            <td>
                                <input ${('checked="checked"' if c.from_version_index == ver_pr else '')} class="compare-radio-button" type="radio" name="ver_source" value="${ver_pr or 'latest'}" data-ver-pos="${ver_pos}"/>
                                <input ${('checked="checked"' if c.at_version_num == ver_pr else '')} class="compare-radio-button" type="radio" name="ver_target" value="${ver_pr or 'latest'}" data-ver-pos="${ver_pos}"/>
                            </td>
                            <td>
                             <% review_status = c.review_versions[ver_pr].status if ver_pr in c.review_versions else 'not_reviewed' %>
                             <i class="tooltip icon-circle review-status-${review_status}" title="${_('Your review status at this version')}"></i>
 
                            </td>
                            <td>
                                % if c.at_version_num != ver_pr:
                                 <i class="tooltip icon-comment" title="${_('Comments from pull request version v{0}').format(ver_pos)}"></i>
                                 <code>
                                    General:${len(c.comment_versions[ver_pr]['at'])} / Inline:${len(c.inline_versions[ver_pr]['at'])}
                                 </code>
                                % endif
                            </td>
                            <td>
                                ##<code>${ver.source_ref_parts.commit_id[:6]}</code>
                            </td>
                            <td>
                                <code>${h.age_component(ver.updated_on, time_is_local=True, tooltip=False)}</code>
                            </td>
                        </tr>
                    % endfor
 
                    <tr>
                        <td colspan="6">
                            <button id="show-version-diff" onclick="return versionController.showVersionDiff()" class="btn btn-sm" style="display: none"
                                    data-label-text-locked="${_('select versions to show changes')}"
                                    data-label-text-diff="${_('show changes between versions')}"
                                    data-label-text-show="${_('show pull request for this version')}"
                            >
                                ${_('select versions to show changes')}
                            </button>
                        </td>
                    </tr>
                </table>
            % else:
                <div>
                ${_('Pull request versions not available')}.
                </div>
            % endif
            </div>
        </div>
 
     </div>
 
   </div>
 
 
   </div>
 
 </div>
 
 <div class="box">
 
   % if c.state_progressing:
 
     <h2 style="text-align: center">
         ${_('Cannot show diff when pull request state is changing. Current progress state')}: <span class="tag tag-merge-state-${c.pull_request.state}">${c.pull_request.state}</span>
 
         % if c.is_super_admin:
         <br/>
         If you think this is an error try <a href="${h.current_route_path(request, force_state='created')}">forced state reset</a> to <span class="tag tag-merge-state-created">created</span> state.
         % endif
     </h2>
 
   % else:
 
       ## Diffs rendered here
       <div class="table" >
           <div id="changeset_compare_view_content">
               ##CS
               % if c.missing_requirements:
                 <div class="box">
                   <div class="alert alert-warning">
                     <div>
                       <strong>${_('Missing requirements:')}</strong>
                       ${_('These commits cannot be displayed, because this repository uses the Mercurial largefiles extension, which was not enabled.')}
                     </div>
                   </div>
                 </div>
               % elif c.missing_commits:
                 <div class="box">
                   <div class="alert alert-warning">
                     <div>
                       <strong>${_('Missing commits')}:</strong>
                         ${_('This pull request cannot be displayed, because one or more commits no longer exist in the source repository.')}<br/>
                         ${_('Please update this pull request, push the commits back into the source repository, or consider closing this pull request.')}<br/>
                         ${_('Consider doing a `force update commits` in case you think this is an error.')}
                     </div>
                   </div>
                 </div>
               % elif c.pr_merge_source_commit.changed and not c.pull_request.is_closed():
                 <div class="box">
                   <div class="alert alert-info">
                     <div>
                         <strong>${_('There are new changes for `{}:{}` in source repository, please consider updating this pull request.').format(c.pr_merge_source_commit.ref_spec.type, c.pr_merge_source_commit.ref_spec.name)}</strong>
                     </div>
                   </div>
                 </div>
               % endif
 
               <div class="compare_view_commits_title">
                   % if not c.compare_mode:
 
                     % if c.at_version_index:
                         <h4>
                         ${_('Showing changes at v{}, commenting is disabled.').format(c.at_version_index)}
                         </h4>
                     % endif
 
                     <div class="pull-left">
                       <div class="btn-group">
                           <a class="${('collapsed' if c.collapse_all_commits else '')}" href="#expand-commits" onclick="toggleCommitExpand(this); return false" data-toggle-commits-cnt=${len(c.commit_ranges)} >
                               % if c.collapse_all_commits:
                                 <i class="icon-plus-squared-alt icon-no-margin"></i>
                                 ${_ungettext('Expand {} commit', 'Expand {} commits', len(c.commit_ranges)).format(len(c.commit_ranges))}
                               % else:
                                 <i class="icon-minus-squared-alt icon-no-margin"></i>
                                 ${_ungettext('Collapse {} commit', 'Collapse {} commits', len(c.commit_ranges)).format(len(c.commit_ranges))}
                               % endif
                           </a>
                       </div>
                     </div>
 
                     <div class="pull-right">
                         % if c.allowed_to_update and not c.pull_request.is_closed():
 
                             <div class="btn-group btn-group-actions">
                                 <a id="update_commits" class="btn btn-primary no-margin" onclick="updateController.updateCommits(this); return false">
                                     ${_('Update commits')}
                                 </a>
 
                                 <a id="update_commits_switcher" class="tooltip btn btn-primary btn-more-option" data-toggle="dropdown" aria-pressed="false" role="button" title="${_('more update options')}">
                                     <i class="icon-down"></i>
                                 </a>
 
                                 <div class="btn-action-switcher-container right-align" id="update-commits-switcher">
                                     <ul class="btn-action-switcher" role="menu" style="min-width: 300px;">
                                         <li>
                                             <a href="#forceUpdate" onclick="updateController.forceUpdateCommits(this); return false">
                                                 ${_('Force update commits')}
                                             </a>
                                             <div class="action-help-block">
                                                ${_('Update commits and force refresh this pull request.')}
                                             </div>
                                         </li>
                                     </ul>
                                 </div>
                             </div>
 
                         % else:
                           <a class="tooltip btn disabled pull-right" disabled="disabled" title="${_('Update is disabled for current view')}">${_('Update commits')}</a>
                         % endif
 
                     </div>
                   % endif
               </div>
 
               % if not c.missing_commits:
                 ## COMPARE RANGE DIFF MODE
                 % if c.compare_mode:
                     % if c.at_version:
                     <h4>
                         ${_('Commits and changes between v{ver_from} and {ver_to} of this pull request, commenting is disabled').format(ver_from=c.from_version_index, ver_to=c.at_version_index if c.at_version_index else 'latest')}:
                     </h4>
 
                     <div class="subtitle-compare">
                         ${_('commits added: {}, removed: {}').format(len(c.commit_changes_summary.added), len(c.commit_changes_summary.removed))}
                     </div>
 
                     <div class="container">
                         <table class="rctable compare_view_commits">
                             <tr>
                                 <th></th>
                                 <th>${_('Time')}</th>
                                 <th>${_('Author')}</th>
                                 <th>${_('Commit')}</th>
                                 <th></th>
                                 <th>${_('Description')}</th>
                             </tr>
 
                             % for c_type, commit in c.commit_changes:
                               % if c_type in ['a', 'r']:
                                 <%
                                     if c_type == 'a':
                                         cc_title = _('Commit added in displayed changes')
                                     elif c_type == 'r':
                                         cc_title = _('Commit removed in displayed changes')
                                     else:
                                         cc_title = ''
                                 %>
                                 <tr id="row-${commit.raw_id}" commit_id="${commit.raw_id}" class="compare_select">
                                 <td>
                                     <div class="commit-change-indicator color-${c_type}-border">
                                       <div class="commit-change-content color-${c_type} tooltip" title="${h.tooltip(cc_title)}">
                                         ${c_type.upper()}
                                       </div>
                                     </div>
                                 </td>
                                 <td class="td-time">
                                     ${h.age_component(commit.date)}
                                 </td>
                                 <td class="td-user">
                                     ${base.gravatar_with_user(commit.author, 16, tooltip=True)}
                                 </td>
                                 <td class="td-hash">
                                     <code>
                                         <a href="${h.route_path('repo_commit', repo_name=c.target_repo.repo_name, commit_id=commit.raw_id)}">
                                             r${commit.idx}:${h.short_id(commit.raw_id)}
                                         </a>
                                         ${h.hidden('revisions', commit.raw_id)}
                                     </code>
                                 </td>
                                 <td class="td-message expand_commit" data-commit-id="${commit.raw_id}" title="${_( 'Expand commit message')}" onclick="commitsController.expandCommit(this); return false">
                                     <i class="icon-expand-linked"></i>
                                 </td>
                                 <td class="mid td-description">
                                     <div class="log-container truncate-wrap">
                                         <div class="message truncate" id="c-${commit.raw_id}" data-message-raw="${commit.message}">${h.urlify_commit_message(commit.message, c.repo_name, issues_container=c.referenced_commit_issues)}</div>
                                     </div>
                                 </td>
                             </tr>
                               % endif
                             % endfor
                         </table>
                     </div>
 
                     % endif
 
                 ## Regular DIFF
                 % else:
                     <%include file="/compare/compare_commits.mako" />
                 % endif
 
                 <div class="cs_files">
                     <%namespace name="cbdiffs" file="/codeblocks/diffs.mako"/>
 
                     <%
                         pr_menu_data = {
                             'outdated_comm_count_ver': outdated_comm_count_ver,
                             'pull_request': c.pull_request
                         }
                     %>
 
                     ${cbdiffs.render_diffset_menu(c.diffset, range_diff_on=c.range_diff_on, pull_request_menu=pr_menu_data)}
 
                     % if c.range_diff_on:
                         % for commit in c.commit_ranges:
                             ${cbdiffs.render_diffset(
                               c.changes[commit.raw_id],
                               commit=commit, use_comments=True,
                               collapse_when_files_over=5,
                               disable_new_comments=True,
                               deleted_files_comments=c.deleted_files_comments,
                               inline_comments=c.inline_comments,
                               pull_request_menu=pr_menu_data, show_todos=False)}
                         % endfor
                     % else:
                         ${cbdiffs.render_diffset(
                           c.diffset, use_comments=True,
                           collapse_when_files_over=30,
                           disable_new_comments=not c.allowed_to_comment,
                           deleted_files_comments=c.deleted_files_comments,
                           inline_comments=c.inline_comments,
                           pull_request_menu=pr_menu_data, show_todos=False)}
                     % endif
 
                 </div>
               % else:
                   ## skipping commits we need to clear the view for missing commits
                   <div style="clear:both;"></div>
               % endif
 
           </div>
       </div>
 
       ## template for inline comment form
       <%namespace name="comment" file="/changeset/changeset_file_comment.mako"/>
 
       ## comments heading with count
       <div class="comments-heading">
         <i class="icon-comment"></i>
         ${_('General Comments')} ${len(c.comments)}
       </div>
 
       ## render general comments
       <div id="comment-tr-show">
         % if general_outdated_comm_count_ver:
         <div class="info-box">
             % if general_outdated_comm_count_ver == 1:
                 ${_('there is {num} general comment from older versions').format(num=general_outdated_comm_count_ver)},
                 <a href="#show-hidden-comments" onclick="$('.comment-general.comment-outdated').show(); $(this).parent().hide(); return false;">${_('show it')}</a>
             % else:
                 ${_('there are {num} general comments from older versions').format(num=general_outdated_comm_count_ver)},
                 <a href="#show-hidden-comments" onclick="$('.comment-general.comment-outdated').show(); $(this).parent().hide(); return false;">${_('show them')}</a>
             % endif
         </div>
         % endif
       </div>
 
       ${comment.generate_comments(c.comments, include_pull_request=True, is_pull_request=True)}
 
       % if not c.pull_request.is_closed():
         ## main comment form and it status
         ${comment.comments(h.route_path('pullrequest_comment_create', repo_name=c.repo_name,
                                         pull_request_id=c.pull_request.pull_request_id),
                            c.pull_request_review_status,
                            is_pull_request=True, change_status=c.allowed_to_change_status)}
 
         ## merge status, and merge action
         <div class="pull-request-merge">
             <%include file="/pullrequests/pullrequest_merge_checks.mako"/>
         </div>
 
       %endif
 
    % endif
   </div>
 
 
 ### NAV SIDEBAR
 <aside class="right-sidebar right-sidebar-expanded" id="pr-nav-sticky" style="display: none">
     <div class="sidenav navbar__inner" >
         ## TOGGLE
         <div class="sidebar-toggle" onclick="toggleSidebar(); return false">
             <a href="#toggleSidebar" class="grey-link-action">
 
             </a>
         </div>
 
         ## CONTENT
         <div class="sidebar-content">
 
             ## RULES SUMMARY/RULES
             <div class="sidebar-element clear-both">
                 <% vote_title = _ungettext(
                         'Status calculated based on votes from {} reviewer',
-                        'Status calculated based on votes from {} reviewers', len(c.allowed_reviewers)).format(len(c.allowed_reviewers))
+                        'Status calculated based on votes from {} reviewers', c.reviewers_count).format(c.reviewers_count)
                 %>
 
                 <div class="tooltip right-sidebar-collapsed-state" style="display: none" onclick="toggleSidebar(); return false" title="${vote_title}">
                     <i class="icon-circle review-status-${c.pull_request_review_status}"></i>
-                    ${len(c.allowed_reviewers)}
+                    ${c.reviewers_count}
                 </div>
 
                 ## REVIEW RULES
                 <div id="review_rules" style="display: none" class="">
                     <div class="right-sidebar-expanded-state pr-details-title">
                         <span class="sidebar-heading">
                             ${_('Reviewer rules')}
                         </span>
 
                     </div>
                     <div class="pr-reviewer-rules">
                         ## review rules will be appended here, by default reviewers logic
                     </div>
                     <input id="review_data" type="hidden" name="review_data" value="">
                 </div>
 
                 ## REVIEWERS
                 <div class="right-sidebar-expanded-state pr-details-title">
                     <span class="tooltip sidebar-heading" title="${vote_title}">
                         <i class="icon-circle review-status-${c.pull_request_review_status}"></i>
                         ${_('Reviewers')}
                     </span>
                     %if c.allowed_to_update:
                         <span id="open_edit_reviewers" class="block-right action_button last-item">${_('Edit')}</span>
                         <span id="close_edit_reviewers" class="block-right action_button last-item" style="display: none;">${_('Close')}</span>
                     %else:
                         <span id="open_edit_reviewers" class="block-right action_button last-item">${_('Show rules')}</span>
                         <span id="close_edit_reviewers" class="block-right action_button last-item" style="display: none;">${_('Close')}</span>
                     %endif
                 </div>
 
                 <div id="reviewers" class="right-sidebar-expanded-state pr-details-content reviewers">
 
                     ## members redering block
                     <input type="hidden" name="__start__" value="review_members:sequence">
 
                     <table id="review_members" class="group_members">
                     ## This content is loaded via JS and ReviewersPanel
                     </table>
 
                     <input type="hidden" name="__end__" value="review_members:sequence">
                     ## end members redering block
 
                     %if not c.pull_request.is_closed():
                         <div id="add_reviewer" class="ac" style="display: none;">
                         %if c.allowed_to_update:
                             % if not c.forbid_adding_reviewers:
-                                <div id="add_reviewer_input" class="reviewer_ac">
-                                   ${h.text('user', class_='ac-input', placeholder=_('Add reviewer or reviewer group'))}
+                                <div id="add_reviewer_input" class="reviewer_ac" style="width: 240px">
+                                   <input class="ac-input" id="user" name="user" placeholder="${_('Add reviewer or reviewer group')}" type="text" autocomplete="off">
                                    <div id="reviewers_container"></div>
                                 </div>
                             % endif
-                            <div class="pull-right">
-                                <button id="update_pull_request" class="btn btn-small no-margin">${_('Save Changes')}</button>
+                            <div class="pull-right" style="margin-bottom: 15px">
+                                <button data-role="reviewer" id="update_reviewers" class="btn btn-small no-margin">${_('Save Changes')}</button>
                             </div>
                         %endif
                         </div>
                     %endif
                 </div>
             </div>
 
-##             ## OBSERVERS
-##             <div class="sidebar-element clear-both">
-##                 <div class="tooltip right-sidebar-collapsed-state" style="display: none" onclick="toggleSidebar(); return false" title="${_('Observers')}">
-##                     <i class="icon-eye"></i>
-##                     0
-##                 </div>
-##
-##                 <div class="right-sidebar-expanded-state pr-details-title">
-##                   <span class="sidebar-heading">
-##                     <i class="icon-eye"></i>
-##                     ${_('Observers')}
-##                   </span>
-##                 </div>
-##                 <div class="right-sidebar-expanded-state pr-details-content">
-##                     No observers
-##                 </div>
-##             </div>
+            ## OBSERVERS
+            <div class="sidebar-element clear-both">
+                <div class="tooltip right-sidebar-collapsed-state" style="display: none" onclick="toggleSidebar(); return false" title="${_('Observers')}">
+                    <i class="icon-circle-thin"></i>
+                    ${c.observers_count}
+                </div>
+
+                <div class="right-sidebar-expanded-state pr-details-title">
+                  <span class="sidebar-heading">
+                    <i class="icon-circle-thin"></i>
+                    ${_('Observers')}
+                  </span>
+                  %if c.allowed_to_update:
+                      <span id="open_edit_observers" class="block-right action_button last-item">${_('Edit')}</span>
+                      <span id="close_edit_observers" class="block-right action_button last-item" style="display: none;">${_('Close')}</span>
+                  %endif
+                </div>
+
+                <div id="observers" class="right-sidebar-expanded-state pr-details-content reviewers">
+                    ## members redering block
+                    <input type="hidden" name="__start__" value="observer_members:sequence">
+
+                    <table id="observer_members" class="group_members">
+                    ## This content is loaded via JS and ReviewersPanel
+                    </table>
+
+                    <input type="hidden" name="__end__" value="observer_members:sequence">
+                    ## end members redering block
+
+                    %if not c.pull_request.is_closed():
+                        <div id="add_observer" class="ac" style="display: none;">
+                        %if c.allowed_to_update:
+                            % if not c.forbid_adding_reviewers or 1:
+                                <div id="add_reviewer_input" class="reviewer_ac" style="width: 240px" >
+                                   <input class="ac-input" id="observer" name="observer" placeholder="${_('Add observer or observer group')}" type="text" autocomplete="off">
+                                   <div id="observers_container"></div>
+                                </div>
+                            % endif
+                            <div class="pull-right" style="margin-bottom: 15px">
+                                <button data-role="observer" id="update_observers" class="btn btn-small no-margin">${_('Save Changes')}</button>
+                            </div>
+                        %endif
+                        </div>
+                    %endif
+                </div>
+            </div>
 
             ## TODOs
             <div class="sidebar-element clear-both">
                 <div class="tooltip right-sidebar-collapsed-state" style="display: none" onclick="toggleSidebar(); return false" title="TODOs">
                   <i class="icon-flag-filled"></i>
                   <span id="todos-count">${len(c.unresolved_comments)}</span>
                 </div>
 
                 <div class="right-sidebar-expanded-state pr-details-title">
                       ## Only show unresolved, that is only what matters
                       <span class="sidebar-heading noselect" onclick="refreshTODOs(); return false">
                       <i class="icon-flag-filled"></i>
                       TODOs
                       </span>
 
                       % if not c.at_version:
                           % if c.resolved_comments:
                               <span class="block-right action_button last-item noselect" onclick="$('.unresolved-todo-text').toggle(); return toggleElement(this, '.resolved-todo');" data-toggle-on="Show resolved" data-toggle-off="Hide resolved">Show resolved</span>
                           % else:
                               <span class="block-right last-item noselect">Show resolved</span>
                           % endif
                       % endif
                   </div>
 
                 <div class="right-sidebar-expanded-state pr-details-content">
 
                   % if c.at_version:
                       <table>
                           <tr>
                             <td class="unresolved-todo-text">${_('TODOs unavailable when browsing versions')}.</td>
                           </tr>
                       </table>
                   % else:
                     % if c.unresolved_comments + c.resolved_comments:
                       ${sidebar.comments_table(c.unresolved_comments + c.resolved_comments, len(c.unresolved_comments), todo_comments=True)}
                     % else:
                         <table>
                             <tr>
                                 <td>
                                     ${_('No TODOs yet')}
                                 </td>
                             </tr>
                         </table>
                     % endif
                   % endif
                 </div>
             </div>
 
             ## COMMENTS
             <div class="sidebar-element clear-both">
                 <div class="tooltip right-sidebar-collapsed-state" style="display: none" onclick="toggleSidebar(); return false" title="${_('Comments')}">
                     <i class="icon-comment" style="color: #949494"></i>
                     <span id="comments-count">${len(c.inline_comments_flat+c.comments)}</span>
                     <span class="display-none" id="general-comments-count">${len(c.comments)}</span>
                     <span class="display-none" id="inline-comments-count">${len(c.inline_comments_flat)}</span>
                 </div>
 
                 <div class="right-sidebar-expanded-state pr-details-title">
                   <span class="sidebar-heading noselect" onclick="refreshComments(); return false">
                     <i class="icon-comment" style="color: #949494"></i>
                     ${_('Comments')}
 
 ##                    % if outdated_comm_count_ver:
 ##                         <a href="#" onclick="showOutdated(); Rhodecode.comments.nextOutdatedComment(); return false;">
 ##                             (${_("{} Outdated").format(outdated_comm_count_ver)})
 ##                         </a>
 ##                         <a href="#" class="showOutdatedComments" onclick="showOutdated(this); return false;"> | ${_('show outdated')}</a>
 ##                         <a href="#" class="hideOutdatedComments" style="display: none" onclick="hideOutdated(this); return false;"> | ${_('hide outdated')}</a>
 
 ##                         % else:
 ##                             (${_("{} Outdated").format(outdated_comm_count_ver)})
 ##                    % endif
 
                   </span>
 
                   % if outdated_comm_count_ver:
                     <span class="block-right action_button last-item noselect" onclick="return toggleElement(this, '.hidden-comment');" data-toggle-on="Show outdated" data-toggle-off="Hide outdated">Show outdated</span>
                   % else:
                     <span class="block-right last-item noselect">Show hidden</span>
                   % endif
 
                 </div>
 
                 <div class="right-sidebar-expanded-state pr-details-content">
                 % if c.inline_comments_flat + c.comments:
                     ${sidebar.comments_table(c.inline_comments_flat + c.comments, len(c.inline_comments_flat+c.comments))}
                 % else:
                     <table>
                         <tr>
                             <td>
                                 ${_('No Comments yet')}
                             </td>
                         </tr>
                     </table>
                 % endif
                 </div>
 
             </div>
 
             ## Referenced Tickets
             <div class="sidebar-element clear-both">
                 <div class="tooltip right-sidebar-collapsed-state" style="display: none" onclick="toggleSidebar(); return false" title="${_('Referenced Tickets')}">
                     <i class="icon-info-circled"></i>
                     ${(len(c.referenced_desc_issues) + len(c.referenced_commit_issues))}
                 </div>
 
                 <div class="right-sidebar-expanded-state pr-details-title">
                   <span class="sidebar-heading">
                     <i class="icon-info-circled"></i>
                     ${_('Referenced Tickets')}
                   </span>
                 </div>
                 <div class="right-sidebar-expanded-state pr-details-content">
                     <table>
 
                         <tr><td><code>${_('In pull request description')}:</code></td></tr>
                         % if c.referenced_desc_issues:
                             % for ticket_dict in c.referenced_desc_issues:
                             <tr>
                                 <td>
                                     <a href="${ticket_dict.get('url')}">
                                     ${ticket_dict.get('id')}
                                     </a>
                                 </td>
                             </tr>
                             % endfor
                         % else:
                             <tr>
                                 <td>
                                     ${_('No Ticket data found.')}
                                 </td>
                             </tr>
                         % endif
 
                         <tr><td style="padding-top: 10px"><code>${_('In commit messages')}:</code></td></tr>
                         % if c.referenced_commit_issues:
                             % for ticket_dict in c.referenced_commit_issues:
                             <tr>
                                 <td>
                                     <a href="${ticket_dict.get('url')}">
                                     ${ticket_dict.get('id')}
                                     </a>
                                 </td>
                             </tr>
                             % endfor
                         % else:
                             <tr>
                                 <td>
                                     ${_('No Ticket data found.')}
                                 </td>
                             </tr>
                         % endif
                     </table>
 
                 </div>
             </div>
 
         </div>
 
     </div>
 </aside>
 
 ## This JS needs to be at the end
 <script type="text/javascript">
 
 versionController = new VersionController();
 versionController.init();
 
 reviewersController = new ReviewersController();
 commitsController = new CommitsController();
 
 updateController = new UpdatePrController();
 
 window.reviewerRulesData = ${c.pull_request_default_reviewers_data_json | n};
 window.setReviewersData = ${c.pull_request_set_reviewers_data_json | n};
+window.setObserversData = ${c.pull_request_set_observers_data_json | n};
 
 (function () {
     "use strict";
 
     // custom code mirror
     var codeMirrorInstance = $('#pr-description-input').get(0).MarkupForm.cm;
 
-    var PRDetails = {
-        editButton: $('#open_edit_pullrequest'),
-        closeButton: $('#close_edit_pullrequest'),
-        deleteButton: $('#delete_pullrequest'),
-        viewFields: $('#pr-desc, #pr-title'),
-        editFields: $('#pr-desc-edit, #pr-title-edit, .pr-save'),
-
-        init: function () {
-            var that = this;
-            this.editButton.on('click', function (e) {
-                that.edit();
-            });
-            this.closeButton.on('click', function (e) {
-                that.view();
-            });
-        },
-
-        edit: function (event) {
-            var cmInstance = $('#pr-description-input').get(0).MarkupForm.cm;
-            this.viewFields.hide();
-            this.editButton.hide();
-            this.deleteButton.hide();
-            this.closeButton.show();
-            this.editFields.show();
-            cmInstance.refresh();
-        },
-
-        view: function (event) {
-            this.editButton.show();
-            this.deleteButton.show();
-            this.editFields.hide();
-            this.closeButton.hide();
-            this.viewFields.show();
-        }
-    };
-
     PRDetails.init();
     ReviewersPanel.init(reviewerRulesData, setReviewersData);
+    ObserversPanel.init(reviewerRulesData, setObserversData);
 
     window.showOutdated = function (self) {
         $('.comment-inline.comment-outdated').show();
         $('.filediff-outdated').show();
         $('.showOutdatedComments').hide();
         $('.hideOutdatedComments').show();
     };
 
     window.hideOutdated = function (self) {
         $('.comment-inline.comment-outdated').hide();
         $('.filediff-outdated').hide();
         $('.hideOutdatedComments').hide();
         $('.showOutdatedComments').show();
     };
 
     window.refreshMergeChecks = function () {
         var loadUrl = "${request.current_route_path(_query=dict(merge_checks=1))}";
         $('.pull-request-merge').css('opacity', 0.3);
         $('.action-buttons-extra').css('opacity', 0.3);
 
         $('.pull-request-merge').load(
                 loadUrl, function () {
                     $('.pull-request-merge').css('opacity', 1);
 
                     $('.action-buttons-extra').css('opacity', 1);
                 }
         );
     };
 
     window.closePullRequest = function (status) {
         if (!confirm(_gettext('Are you sure to close this pull request without merging?'))) {
             return false;
         }
         // inject closing flag
         $('.action-buttons-extra').append('<input type="hidden" class="close-pr-input" id="close_pull_request" value="1">');
         $(generalCommentForm.statusChange).select2("val", status).trigger('change');
         $(generalCommentForm.submitForm).submit();
     };
 
     //TODO this functionality is now missing
     $('#show-outdated-comments').on('click', function (e) {
         var button = $(this);
         var outdated = $('.comment-outdated');
 
         if (button.html() === "(Show)") {
             button.html("(Hide)");
             outdated.show();
         } else {
             button.html("(Show)");
             outdated.hide();
         }
     });
 
     $('#merge_pull_request_form').submit(function () {
         if (!$('#merge_pull_request').attr('disabled')) {
             $('#merge_pull_request').attr('disabled', 'disabled');
         }
         return true;
     });
 
     $('#edit_pull_request').on('click', function (e) {
         var title = $('#pr-title-input').val();
         var description = codeMirrorInstance.getValue();
         var renderer = $('#pr-renderer-input').val();
         editPullRequest(
                 "${c.repo_name}", "${c.pull_request.pull_request_id}",
                 title, description, renderer);
     });
 
-    $('#update_pull_request').on('click', function (e) {
-        $(this).attr('disabled', 'disabled');
-        $(this).addClass('disabled');
-        $(this).html(_gettext('Saving...'));
+    var $updateButtons = $('#update_reviewers,#update_observers');
+    $updateButtons.on('click', function (e) {
+        var role = $(this).data('role');
+        $updateButtons.attr('disabled', 'disabled');
+        $updateButtons.addClass('disabled');
+        $updateButtons.html(_gettext('Saving...'));
         reviewersController.updateReviewers(
-                "${c.repo_name}", "${c.pull_request.pull_request_id}");
+                templateContext.repo_name,
+                templateContext.pull_request_data.pull_request_id,
+                role
+        );
     });
 
     // fixing issue with caches on firefox
     $('#update_commits').removeAttr("disabled");
 
     $('.show-inline-comments').on('click', function (e) {
         var boxid = $(this).attr('data-comment-id');
         var button = $(this);
 
         if (button.hasClass("comments-visible")) {
             $('#{0} .inline-comments'.format(boxid)).each(function (index) {
                 $(this).hide();
             });
             button.removeClass("comments-visible");
         } else {
             $('#{0} .inline-comments'.format(boxid)).each(function (index) {
                 $(this).show();
             });
             button.addClass("comments-visible");
         }
     });
 
     $('.show-inline-comments').on('change', function (e) {
         var show = 'none';
         var target = e.currentTarget;
         if (target.checked) {
             show = ''
         }
         var boxid = $(target).attr('id_for');
         var comments = $('#{0} .inline-comments'.format(boxid));
         var fn_display = function (idx) {
             $(this).css('display', show);
         };
         $(comments).each(fn_display);
         var btns = $('#{0} .inline-comments-button'.format(boxid));
         $(btns).each(fn_display);
     });
 
     // register submit callback on commentForm form to track TODOs
     window.commentFormGlobalSubmitSuccessCallback = function () {
         refreshMergeChecks();
     };
 
-    ReviewerAutoComplete('#user');
+    ReviewerAutoComplete('#user', reviewersController);
+    ObserverAutoComplete('#observer', reviewersController);
 
 })();
 
 $(document).ready(function () {
 
     var channel = '${c.pr_broadcast_channel}';
     new ReviewerPresenceController(channel)
 
 })
 </script>
 
 </%def>

rhodecode/tests/lib/test_mako_emails.py

@@ -1,190 +1,195 b''
 # -*- coding: utf-8 -*-
 
 # Copyright (C) 2010-2020 RhodeCode GmbH
 #
 # This program is free software: you can redistribute it and/or modify
 # it under the terms of the GNU Affero General Public License, version 3
 # (only), as published by the Free Software Foundation.
 #
 # 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 Affero General Public License
 # along with this program.  If not, see <http://www.gnu.org/licenses/>.
 #
 # This program is dual-licensed. If you wish to learn more about the
 # RhodeCode Enterprise Edition, including its added features, Support services,
 # and proprietary license terms, please see https://rhodecode.com/licenses/
 
 import pytest
 import collections
 
 from rhodecode.lib.partial_renderer import PyramidPartialRenderer
 from rhodecode.lib.utils2 import AttributeDict
-from rhodecode.model.db import User
+from rhodecode.model.db import User, PullRequestReviewers
 from rhodecode.model.notification import EmailNotificationModel
 
 
 def test_get_template_obj(app, request_stub):
     template = EmailNotificationModel().get_renderer(
         EmailNotificationModel.TYPE_TEST, request_stub)
     assert isinstance(template, PyramidPartialRenderer)
 
 
 def test_render_email(app, http_host_only_stub):
     kwargs = {}
     subject, body, body_plaintext = EmailNotificationModel().render_email(
         EmailNotificationModel.TYPE_TEST, **kwargs)
 
     # subject
     assert subject == 'Test "Subject" hello "world"'
 
     # body plaintext
     assert body_plaintext == 'Email Plaintext Body'
 
     # body
     notification_footer1 = 'This is a notification from RhodeCode.'
     notification_footer2 = 'http://{}/'.format(http_host_only_stub)
     assert notification_footer1 in body
     assert notification_footer2 in body
     assert 'Email Body' in body
 
 
-def test_render_pr_email(app, user_admin):
[e-mail]('role', PullRequestReviewers.ROLES)
+def test_render_pr_email(app, user_admin, role):
     ref = collections.namedtuple(
         'Ref', 'name, type')('fxies123', 'book')
 
     pr = collections.namedtuple('PullRequest',
         'pull_request_id, title, description, source_ref_parts, source_ref_name, target_ref_parts, target_ref_name')(
         200, 'Example Pull Request', 'Desc of PR', ref, 'bookmark', ref, 'Branch')
 
     source_repo = target_repo = collections.namedtuple(
         'Repo', 'type, repo_name')('hg', 'pull_request_1')
 
     kwargs = {
         'user': User.get_first_super_admin(),
         'pull_request': pr,
         'pull_request_commits': [],
 
         'pull_request_target_repo': target_repo,
         'pull_request_target_repo_url': 'x',
 
         'pull_request_source_repo': source_repo,
         'pull_request_source_repo_url': 'x',
 
         'pull_request_url': 'http://localhost/pr1',
+        'user_role': role,
     }
 
     subject, body, body_plaintext = EmailNotificationModel().render_email(
         EmailNotificationModel.TYPE_PULL_REQUEST, **kwargs)
 
     # subject
-    assert subject == '@test_admin (RhodeCode Admin) requested a pull request review. !200: "Example Pull Request"'
+    if role == PullRequestReviewers.ROLE_REVIEWER:
+        assert subject == '@test_admin (RhodeCode Admin) requested a pull request review. !200: "Example Pull Request"'
+    elif role == PullRequestReviewers.ROLE_OBSERVER:
+        assert subject == '@test_admin (RhodeCode Admin) added you as observer to pull request. !200: "Example Pull Request"'
 
 
 def test_render_pr_update_email(app, user_admin):
     ref = collections.namedtuple(
         'Ref', 'name, type')('fxies123', 'book')
 
     pr = collections.namedtuple('PullRequest',
         'pull_request_id, title, description, source_ref_parts, source_ref_name, target_ref_parts, target_ref_name')(
         200, 'Example Pull Request', 'Desc of PR', ref, 'bookmark', ref, 'Branch')
 
     source_repo = target_repo = collections.namedtuple(
         'Repo', 'type, repo_name')('hg', 'pull_request_1')
 
     commit_changes = AttributeDict({
         'added': ['aaaaaaabbbbb', 'cccccccddddddd'],
         'removed': ['eeeeeeeeeee'],
     })
     file_changes = AttributeDict({
         'added': ['a/file1.md', 'file2.py'],
         'modified': ['b/modified_file.rst'],
         'removed': ['.idea'],
     })
 
     kwargs = {
         'updating_user': User.get_first_super_admin(),
 
         'pull_request': pr,
         'pull_request_commits': [],
 
         'pull_request_target_repo': target_repo,
         'pull_request_target_repo_url': 'x',
 
         'pull_request_source_repo': source_repo,
         'pull_request_source_repo_url': 'x',
 
         'pull_request_url': 'http://localhost/pr1',
 
         'pr_comment_url': 'http://comment-url',
         'pr_comment_reply_url': 'http://comment-url#reply',
         'ancestor_commit_id': 'f39bd443',
         'added_commits': commit_changes.added,
         'removed_commits': commit_changes.removed,
         'changed_files': (file_changes.added + file_changes.modified + file_changes.removed),
         'added_files': file_changes.added,
         'modified_files': file_changes.modified,
         'removed_files': file_changes.removed,
     }
 
     subject, body, body_plaintext = EmailNotificationModel().render_email(
         EmailNotificationModel.TYPE_PULL_REQUEST_UPDATE, **kwargs)
 
     # subject
     assert subject == '@test_admin (RhodeCode Admin) updated pull request. !200: "Example Pull Request"'
 
 
 @pytest.mark.parametrize('mention', [
     True,
     False
 ])
 @pytest.mark.parametrize('email_type', [
     EmailNotificationModel.TYPE_COMMIT_COMMENT,
     EmailNotificationModel.TYPE_PULL_REQUEST_COMMENT
 ])
 def test_render_comment_subject_no_newlines(app, mention, email_type):
     ref = collections.namedtuple(
         'Ref', 'name, type')('fxies123', 'book')
 
     pr = collections.namedtuple('PullRequest',
         'pull_request_id, title, description, source_ref_parts, source_ref_name, target_ref_parts, target_ref_name')(
         200, 'Example Pull Request', 'Desc of PR', ref, 'bookmark', ref, 'Branch')
 
     source_repo = target_repo = collections.namedtuple(
         'Repo', 'type, repo_name')('hg', 'pull_request_1')
 
     kwargs = {
         'user': User.get_first_super_admin(),
         'commit': AttributeDict(raw_id='a'*40, message='Commit message'),
         'status_change': 'approved',
         'commit_target_repo_url': 'http://foo.example.com/#comment1',
         'repo_name': 'test-repo',
         'comment_file': 'test-file.py',
         'comment_line': 'n100',
         'comment_type': 'note',
         'comment_id': 2048,
         'commit_comment_url': 'http://comment-url',
         'commit_comment_reply_url': 'http://comment-url/#Reply',
         'instance_url': 'http://rc-instance',
         'comment_body': 'hello world',
         'mention': mention,
 
         'pr_comment_url': 'http://comment-url',
         'pr_comment_reply_url': 'http://comment-url/#Reply',
         'pull_request': pr,
         'pull_request_commits': [],
 
         'pull_request_target_repo': target_repo,
         'pull_request_target_repo_url': 'x',
 
         'pull_request_source_repo': source_repo,
         'pull_request_source_repo_url': 'x',
 
         'pull_request_url': 'http://code.rc.com/_pr/123'
     }
     subject, body, body_plaintext = EmailNotificationModel().render_email(email_type, **kwargs)
 
     assert '\n' not in subject