comments: introduce new draft comments.

- private to author
- not triggering any notifications
- sidebar doesn't display draft comments
- They are just placeholders for longer review.

rhodecode/lib/dbmigrate/versions/111_version_4_23_0.py

@@ -0,0 +1,53 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.ChangesetComment.__table__
+    with op.batch_alter_table(table.name) as batch_op:
+        new_column = Column('draft', Boolean(), nullable=True)
+        batch_op.add_column(new_column)
+
+    _set_default_as_non_draft(op, meta.Session)
+
+
+def downgrade(migrate_engine):
+    meta = MetaData()
+    meta.bind = migrate_engine
+
+
+def fixups(models, _SESSION):
+    pass
+
+
+def _set_default_as_non_draft(op, session):
+    params = {'draft': False}
+    query = text(
+        'UPDATE changeset_comments SET draft = :draft'
+    ).bindparams(**params)
+    op.execute(query)
+    session().commit()
+

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__ = 110  # defines current db version for migrations
+__dbversion__ = 111  # 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/apps/repository/views/repo_pull_requests.py

@@ -1,1816 +1,1826 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, aslist
 from rhodecode.lib.vcs.backends.base import (
     EmptyCommit, UpdateFailureReason, unicode_to_reference)
 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, false, 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_count = comments_model.get_all_comments(
                 self.db_repo.repo_id, pull_request=pr, count_only=True)
 
             data.append({
                 'name': _render('pullrequest_name',
                                 pr.pull_request_id, pr.pull_request_state,
                                 pr.work_in_progress, pr.target_repo.repo_name,
                                 short=True),
                 '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', comments_count),
                 'comments_raw': comments_count,
                 '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):
+    def register_comments_vars(self, c, pull_request, versions, include_drafts=True):
         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())
+        if not include_drafts:
+            q = q.filter(ChangesetComment.draft == false())
         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())
+        if not include_drafts:
+            q = q.filter(ChangesetComment.draft == false())
         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 = channelstream.pr_channel(pull_request)
 
         _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.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 = {}
             is_reviewer = PullRequestModel().is_user_reviewer(
                 pull_request, self._rhodecode_user)
             if is_reviewer:
                 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
 
     def _get_existing_ids(self, post_data):
         return filter(lambda e: e, map(safe_int, aslist(post_data.get('comments'), ',')))
 
     @LoginRequired()
     @NotAnonymous()
     @HasRepoPermissionAnyDecorator(
         'repository.read', 'repository.write', 'repository.admin')
     @view_config(
         route_name='pullrequest_comments', request_method='POST',
         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)
+        self.register_comments_vars(c, pull_request_latest, versions, include_drafts=False)
         all_comments = c.inline_comments_flat + c.comments
 
         existing_ids = self._get_existing_ids(self.request.POST)
         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_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)
+            .get_pull_request_unresolved_todos(pull_request, include_drafts=False)
         c.resolved_comments = CommentsModel() \
-            .get_pull_request_resolved_todos(pull_request)
+            .get_pull_request_resolved_todos(pull_request, include_drafts=False)
 
         all_comments = c.unresolved_comments + c.resolved_comments
         existing_ids = self._get_existing_ids(self.request.POST)
         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_ref_obj = unicode_to_reference(source_ref)
         target_ref_obj = unicode_to_reference(target_ref)
 
         source_commit = source_scm.get_commit(source_ref_obj.commit_id)
         target_commit = target_scm.get_commit(target_ref_obj.commit_id)
 
         ancestor = source_scm.get_common_ancestor(
             source_commit.raw_id, target_commit.raw_id, target_scm)
 
         # recalculate target ref based on ancestor
         target_ref = ':'.join((target_ref_obj.type, target_ref_obj.name, ancestor))
 
         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_ref_obj,
             target_db_repo,
             target_ref_obj,
             include_diff_info=False)
 
         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_obj.name
         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 = channelstream.pr_channel(pull_request)
 
         # 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,
                     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}.')
             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')
             channelstream.pr_update_channelstream_push(
                 self.request, c.pr_broadcast_channel, self._rhodecode_user, 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_db_user)
 
             Session().commit()
 
             msg = _('Pull request reviewers updated.')
             h.flash(msg, category='success')
             channelstream.pr_update_channelstream_push(
                 self.request, c.pr_broadcast_channel, self._rhodecode_user, 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_db_user)
 
             Session().commit()
             msg = _('Pull request observers updated.')
             h.flash(msg, category='success')
             channelstream.pr_update_channelstream_push(
                 self.request, c.pr_broadcast_channel, self._rhodecode_user, 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')
 
     @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')
             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')
+        is_draft = str2bool(self.request.POST.get('draft'))
         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()
             is_inline = comment.is_inline
 
             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
-
+            # Additionally ENSURE if somehow draft is sent we're then unable to change status
             allowed_to_change_status = PullRequestModel().check_user_change_status(
-                pull_request, self._rhodecode_user)
+                pull_request, self._rhodecode_user) and not is_draft
 
             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,
+                is_draft=is_draft,
                 resolves_comment_id=resolves_comment_id,
-                auth_user=self._rhodecode_user
+                auth_user=self._rhodecode_user,
+                send_email=not is_draft,  # skip notification for draft comments
             )
             is_inline = comment.is_inline
 
             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})
 
+            # skip channelstream for draft comments
+            if not is_draft:
             comment_broadcast_channel = channelstream.comment_channel(
                 self.db_repo_name, pull_request_obj=pull_request)
 
             comment_data = data
             comment_type = 'inline' if is_inline else 'general'
             channelstream.comment_channelstream_push(
                 self.request, comment_broadcast_channel, self._rhodecode_user,
                 _('posted a new {} comment').format(comment_type),
                 comment_data=comment_data)
 
         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/model/comment.py

@@ -1,821 +1,843 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 (
+    false,
     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):
+    def get_pull_request_unresolved_todos(self, pull_request, show_outdated=True, include_drafts=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 include_drafts:
+            todos = todos.filter(ChangesetComment.draft == false())
+
         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):
+    def get_pull_request_resolved_todos(self, pull_request, show_outdated=True, include_drafts=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 include_drafts:
+            todos = todos.filter(ChangesetComment.draft == false())
+
         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):
+    def get_commit_unresolved_todos(self, commit_id, show_outdated=True, include_drafts=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 include_drafts:
+            todos = todos.filter(ChangesetComment.draft == false())
+
         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):
+    def get_commit_resolved_todos(self, commit_id, show_outdated=True, include_drafts=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 include_drafts:
+            todos = todos.filter(ChangesetComment.draft == false())
+
         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):
+    def get_commit_inline_comments(self, commit_id, include_drafts=True):
         inline_comments = Session().query(ChangesetComment) \
             .filter(ChangesetComment.line_no != None) \
             .filter(ChangesetComment.f_path != None) \
             .filter(ChangesetComment.revision == commit_id)
+
+        if not include_drafts:
+            inline_comments = inline_comments.filter(ChangesetComment.draft == false())
+
         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,
+               status_change_type=None, comment_type=None, is_draft=False,
                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 is_draft: is comment a draft only
         :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,
+            is_draft=is_draft,
             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,
         ))
+        is_draft = validated_kwargs['is_draft']
 
         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.draft = is_draft
 
         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.get_pull_request_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],
             })
 
         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'
 
+        if not is_draft:
         comment_data = comment.get_api_data()
 
         self._log_audit_action(
             action, {'data': comment_data}, auth_user, comment)
 
         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, count_only=False):
         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_id == pull_request.pull_request_id)
         else:
             raise Exception('Please specify commit or pull_request')
         q = q.order_by(ChangesetComment.created_on)
         if count_only:
             return q.count()
 
         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/validation_schema/schemas/comment_schema.py

@@ -1,74 +1,74 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 os
 
 import colander
 
 from rhodecode.translation import _
 from rhodecode.model.validation_schema import preparers
 from rhodecode.model.validation_schema import types
 
 
 @colander.deferred
 def deferred_lifetime_validator(node, kw):
     options = kw.get('lifetime_options', [])
     return colander.All(
         colander.Range(min=-1, max=60 * 24 * 30 * 12),
         colander.OneOf([x for x in options]))
 
 
 def unique_gist_validator(node, value):
     from rhodecode.model.db import Gist
     existing = Gist.get_by_access_id(value)
     if existing:
         msg = _(u'Gist with name {} already exists').format(value)
         raise colander.Invalid(node, msg)
 
 
 def filename_validator(node, value):
     if value != os.path.basename(value):
         msg = _(u'Filename {} cannot be inside a directory').format(value)
         raise colander.Invalid(node, msg)
 
 
 comment_types = ['note', 'todo']
 
 
 class CommentSchema(colander.MappingSchema):
     from rhodecode.model.db import ChangesetComment, ChangesetStatus
 
     comment_body = colander.SchemaNode(colander.String())
     comment_type = colander.SchemaNode(
         colander.String(),
         validator=colander.OneOf(ChangesetComment.COMMENT_TYPES),
         missing=ChangesetComment.COMMENT_TYPE_NOTE)
-
+    is_draft = colander.SchemaNode(colander.Boolean(),missing=False)
     comment_file = colander.SchemaNode(colander.String(), missing=None)
     comment_line = colander.SchemaNode(colander.String(), missing=None)
     status_change = colander.SchemaNode(
         colander.String(), missing=None,
         validator=colander.OneOf([x[0] for x in ChangesetStatus.STATUSES]))
     renderer_type = colander.SchemaNode(colander.String())
 
     resolves_comment_id = colander.SchemaNode(colander.Integer(), missing=None)
 
     user = colander.SchemaNode(types.StrOrIntType())
     repo = colander.SchemaNode(types.StrOrIntType())

rhodecode/public/css/buttons.less

@@ -1,540 +1,600 b''
 
 
 //BUTTONS
 button,
 .btn,
 input[type="button"] {
     -webkit-appearance: none;
     display: inline-block;
     margin: 0 @padding/3 0 0;
     padding: @button-padding;
     text-align: center;
     font-size: @basefontsize;
     line-height: 1em;
     font-family: @text-light;
     text-decoration: none;
     text-shadow: none;
     color: @grey2;
     background-color: white;
     background-image: none;
     border: none;
     .border ( @border-thickness-buttons, @grey5 );
     .border-radius (@border-radius);
     cursor: pointer;
     white-space: nowrap;
     -webkit-transition: background .3s,color .3s;
        -moz-transition: background .3s,color .3s;
          -o-transition: background .3s,color .3s;
             transition: background .3s,color .3s;
             box-shadow: @button-shadow;
     -webkit-box-shadow: @button-shadow;
 
 
 
     a {
         display: block;
         margin: 0;
         padding: 0;
         color: inherit;
         text-decoration: none;
 
         &:hover {
             text-decoration: none;
         }
     }
 
     &:focus,
     &:active {
         outline:none;
     }
 
     &:hover {
         color: @rcdarkblue;
         background-color: @grey6;
 
     }
 
     &.btn-active {
         color: @rcdarkblue;
         background-color: @grey6;
     }
 
     .icon-remove {
         display: none;
     }
 
     //disabled buttons
     //last; overrides any other styles
     &:disabled {
         opacity: .7;
         cursor: auto;
         background-color: white;
         color: @grey4;
         text-shadow: none;
     }
 
     &.no-margin {
         margin: 0 0 0 0;
     }
 
 
 
 }
 
 
 .btn-default {
     border: @border-thickness solid @grey5;
     background-image: none;
     color: @grey2;
 
     a {
         color: @grey2;
     }
 
     &:hover,
     &.active {
         color: @rcdarkblue;
         background-color: @white;
         .border ( @border-thickness, @grey4 );
 
         a {
             color: @grey2;
         }
     }
     &:disabled {
         .border ( @border-thickness-buttons, @grey5 );
         background-color: transparent;
     }
     &.btn-active {
         color: @rcdarkblue;
         background-color: @white;
         .border ( @border-thickness, @rcdarkblue );
     }
 }
 
 .btn-primary,
 .btn-small, /* TODO: anderson: remove .btn-small to not mix with the new btn-sm */
 .btn-success {
     .border ( @border-thickness, @rcblue );
     background-color: @rcblue;
     color: white;
 
     a {
         color: white;
     }
 
     &:hover,
     &.active {
         .border ( @border-thickness, @rcdarkblue );
         color: white;
         background-color: @rcdarkblue;
 
         a {
             color: white;
         }
     }
     &:disabled {
         background-color: @rcblue;
     }
 }
 
 .btn-secondary {
     &:extend(.btn-default);
 
     background-color: white;
 
     &:focus {
         outline: 0;
     }
 
     &:hover {
         &:extend(.btn-default:hover);
     }
 
     &.btn-link {
         &:extend(.btn-link);
         color: @rcblue;
     }
 
     &:disabled {
         color: @rcblue;
         background-color: white;
     }
 }
 
-.btn-warning,
 .btn-danger,
 .revoke_perm,
 .btn-x,
 .form .action_button.btn-x   {
     .border ( @border-thickness, @alert2 );
     background-color: white;
     color: @alert2;
 
     a {
         color: @alert2;
     }
 
     &:hover,
     &.active {
         .border ( @border-thickness, @alert2 );
         color: white;
         background-color: @alert2;
 
         a {
             color: white;
         }
     }
 
     i {
         display:none;
     }
 
     &:disabled {
         background-color: white;
         color: @alert2;
     }
 }
 
+.btn-warning {
+    .border ( @border-thickness, @alert3 );
+    background-color: white;
+    color: @alert3;
+
+    a {
+        color: @alert3;
+    }
+
+    &:hover,
+    &.active {
+        .border ( @border-thickness, @alert3 );
+        color: white;
+        background-color: @alert3;
+
+        a {
+            color: white;
+        }
+    }
+
+    i {
+        display:none;
+    }
+
+    &:disabled {
+        background-color: white;
+        color: @alert3;
+    }
+}
+
 .btn-approved-status {
     .border ( @border-thickness, @alert1 );
     background-color: white;
     color: @alert1;
 
 }
 
 .btn-rejected-status {
     .border ( @border-thickness, @alert2 );
     background-color: white;
     color: @alert2;
 }
 
 .btn-sm,
 .btn-mini,
 .field-sm .btn {
     padding: @padding/3;
 }
 
 .btn-xs {
     padding: @padding/4;
 }
 
 .btn-lg {
     padding: @padding * 1.2;
 }
 
 .btn-group {
     display: inline-block;
     .btn {
         float: left;
         margin: 0 0 0 0;
         // first item
         &:first-of-type:not(:last-of-type) {
             border-radius: @border-radius 0 0 @border-radius;
 
         }
         // middle elements
         &:not(:first-of-type):not(:last-of-type) {
             border-radius: 0;
             border-left-width: 0;
             border-right-width: 0;
         }
         // last item
         &:last-of-type:not(:first-of-type) {
             border-radius: 0 @border-radius @border-radius 0;
         }
 
         &:only-child {
             border-radius: @border-radius;
         }
     }
 
 }
 
 
 .btn-group-actions {
     position: relative;
     z-index: 50;
 
     &:not(.open) .btn-action-switcher-container {
         display: none;
     }
 
     .btn-more-option {
         margin-left: -1px;
         padding-left: 2px;
         padding-right: 2px;
     }
 }
 
 
 .btn-action-switcher-container {
   position: absolute;
   top: 100%;
 
   &.left-align {
     left: 0;
   }
   &.right-align {
     right: 0;
   }
 
 }
 
 .btn-action-switcher {
     display: block;
     position: relative;
     z-index: 300;
     max-width: 600px;
     margin-top: 4px;
     margin-bottom: 24px;
     font-size: 14px;
     font-weight: 400;
     padding: 8px 0;
     background-color: #fff;
     border: 1px solid @grey4;
     border-radius: 3px;
     box-shadow: @dropdown-shadow;
     overflow: auto;
 
     li {
         display: block;
         text-align: left;
         list-style: none;
         padding: 5px 10px;
     }
 
     li .action-help-block {
         font-size: 10px;
         line-height: normal;
         color: @grey4;
     }
 
 }
 
 .btn-link {
     background: transparent;
     border: none;
     padding: 0;
     color: @rcblue;
 
     &:hover {
         background: transparent;
         border: none;
         color: @rcdarkblue;
     }
 
     //disabled buttons
     //last; overrides any other styles
     &:disabled {
         opacity: .7;
         cursor: auto;
         background-color: white;
         color: @grey4;
         text-shadow: none;
     }
 
     // TODO: johbo: Check if we can avoid this, indicates that the structure
     // is not yet good.
     // lisa: The button CSS reflects the button HTML; both need a cleanup.
     &.btn-danger {
         color: @alert2;
 
         &:hover {
             color: darken(@alert2,30%);
         }
 
         &:disabled {
             color: @alert2;
         }
     }
 }
 
 .btn-social {
     &:extend(.btn-default);
     margin: 5px 5px 5px 0px;
     min-width: 160px;
 }
 
 // TODO: johbo: check these exceptions
 
 .links {
 
     .btn + .btn {
         margin-top: @padding;
     }
 }
 
 
 .action_button {
     display:inline;
     margin: 0;
     padding: 0 1em 0 0;
     font-size: inherit;
     color: @rcblue;
     border: none;
     border-radius: 0;
     background-color: transparent;
 
     &.last-item {
         border: none;
         padding: 0 0 0 0;
     }
 
     &:last-child {
         border: none;
         padding: 0 0 0 0;
     }
 
     &:hover {
         color: @rcdarkblue;
         background-color: transparent;
         border: none;
     }
     .noselect
 }
 
 .grid_delete {
     .action_button {
         border: none;
     }
 }
 
 
+input[type="submit"].btn-warning {
+    &:extend(.btn-warning);
+
+    &:focus {
+        outline: 0;
+    }
+
+    &:hover {
+        &:extend(.btn-warning:hover);
+    }
+
+    &.btn-link {
+        &:extend(.btn-link);
+        color: @alert3;
+
+        &:disabled {
+            color: @alert3;
+            background-color: transparent;
+        }
+    }
+
+    &:disabled {
+        .border ( @border-thickness-buttons, @alert3 );
+        background-color: white;
+        color: @alert3;
+        opacity: 0.5;
+    }
+}
+
+
+
 // TODO: johbo: Form button tweaks, check if we can use the classes instead
 input[type="submit"] {
     &:extend(.btn-primary);
 
     &:focus {
         outline: 0;
     }
 
     &:hover {
         &:extend(.btn-primary:hover);
     }
 
     &.btn-link {
         &:extend(.btn-link);
         color: @rcblue;
 
         &:disabled {
             color: @rcblue;
             background-color: transparent;
         }
     }
 
     &:disabled {
         .border ( @border-thickness-buttons, @rcblue );
         background-color: @rcblue;
         color: white;
         opacity: 0.5;
     }
 }
 
 input[type="reset"] {
     &:extend(.btn-default);
 
     // TODO: johbo: Check if this tweak can be avoided.
     background: transparent;
 
     &:focus {
         outline: 0;
     }
 
     &:hover {
         &:extend(.btn-default:hover);
     }
 
     &.btn-link {
         &:extend(.btn-link);
         color: @rcblue;
 
         &:disabled {
             border: none;
         }
     }
 
     &:disabled {
         .border ( @border-thickness-buttons, @rcblue );
         background-color: white;
         color: @rcblue;
     }
 }
 
 input[type="submit"],
 input[type="reset"] {
     &.btn-danger {
         &:extend(.btn-danger);
 
         &:focus {
             outline: 0;
         }
 
         &:hover {
             &:extend(.btn-danger:hover);
         }
 
         &.btn-link {
             &:extend(.btn-link);
             color: @alert2;
 
             &:hover {
                 color: darken(@alert2,30%);
             }
         }
 
         &:disabled {
             color: @alert2;
             background-color: white;
         }
     }
     &.btn-danger-action {
         .border ( @border-thickness, @alert2 );
         background-color: @alert2;
         color: white;
 
         a {
             color: white;
         }
 
         &:hover {
             background-color: darken(@alert2,20%);
         }
 
         &.active {
             .border ( @border-thickness, @alert2 );
             color: white;
             background-color: @alert2;
 
             a {
                 color: white;
             }
         }
 
         &:disabled {
             background-color: white;
             color: @alert2;
         }
     }
 }
 
 
 .button-links {
     float: left;
     display: inline;
     margin: 0;
     padding-left: 0;
     list-style: none;
     text-align: right;
 
     li {
 
 
     }
 
     li.active {
         background-color: @grey6;
         .border ( @border-thickness, @grey4 );
     }
 
 }

rhodecode/public/css/comments.less

@@ -1,635 +1,642 b''
 // comments.less
 // For use in RhodeCode applications;
 // see style guide documentation for guidelines.
 
 
 // Comments
 @comment-outdated-opacity: 0.6;
 
 .comments {
     width: 100%;
 }
 
 .comments-heading {
     margin-bottom: -1px;
     background: @grey6;
     display: block;
     padding: 10px 0px;
     font-size: 18px
 }
 
 #comment-tr-show {
     padding: 5px 0;
 }
 
 tr.inline-comments div {
     max-width: 100%;
 
     p {
         white-space: normal;
     }
 
     code, pre, .code, dd {
         overflow-x: auto;
         width: 1062px;
     }
 
     dd {
         width: auto;
     }
 }
 
 #injected_page_comments {
     .comment-previous-link,
     .comment-next-link,
     .comment-links-divider {
         display: none;
     }
 }
 
 .add-comment {
     margin-bottom: 10px;
 }
 .hide-comment-button .add-comment {
     display: none;
 }
 
 .comment-bubble {
     color: @grey4;
     margin-top: 4px;
     margin-right: 30px;
     visibility: hidden;
 }
 
+.comment-draft {
+    float: left;
+    margin-right: 10px;
+    font-weight: 600;
+    color: @alert3;
+}
+
 .comment-label {
     float: left;
 
     padding: 0.4em 0.4em;
     margin: 2px 4px 0px 0px;
     display: inline-block;
     min-height: 0;
 
     text-align: center;
     font-size: 10px;
     line-height: .8em;
 
     font-family: @text-italic;
     font-style: italic;
     background: #fff none;
     color: @grey3;
     border: 1px solid @grey4;
     white-space: nowrap;
 
     text-transform: uppercase;
     min-width: 50px;
     border-radius: 4px;
 
     &.todo {
         color: @color5;
         font-style: italic;
         font-weight: @text-bold-italic-weight;
         font-family: @text-bold-italic;
     }
 
     .resolve {
         cursor: pointer;
         text-decoration: underline;
     }
 
     .resolved {
         text-decoration: line-through;
         color: @color1;
     }
     .resolved a {
         text-decoration: line-through;
         color: @color1;
     }
     .resolve-text {
         color: @color1;
         margin: 2px 8px;
         font-family: @text-italic;
         font-style: italic;
     }
 }
 
 .has-spacer-after {
     &:after {
         content: ' | ';
         color: @grey5;
     }
 }
 
 .has-spacer-before {
     &:before {
         content: ' | ';
         color: @grey5;
     }
 }
 
 .comment {
 
     &.comment-general {
         border: 1px solid @grey5;
         padding: 5px 5px 5px 5px;
     }
 
     margin: @padding 0;
     padding: 4px 0 0 0;
     line-height: 1em;
 
     .rc-user {
         min-width: 0;
         margin: 0px .5em 0 0;
 
         .user {
             display: inline;
         }
     }
 
     .meta {
         position: relative;
         width: 100%;
         border-bottom: 1px solid @grey5;
         margin: -5px 0px;
         line-height: 24px;
 
         &:hover .permalink {
             visibility: visible;
             color: @rcblue;
         }
     }
 
     .author,
     .date {
         display: inline;
 
         &:after {
             content: ' | ';
             color: @grey5;
         }
     }
 
     .author-general img {
         top: 3px;
     }
     .author-inline img {
         top: 3px;
     }
 
     .status-change,
     .permalink,
     .changeset-status-lbl {
         display: inline;
     }
 
     .permalink {
         visibility: hidden;
     }
 
     .comment-links-divider {
         display: inline;
     }
 
     .comment-links-block {
         float:right;
         text-align: right;
         min-width: 85px;
 
         [class^="icon-"]:before,
         [class*=" icon-"]:before {
             margin-left: 0;
             margin-right: 0;
         }
     }
 
     .comment-previous-link {
         display: inline-block;
 
         .arrow_comment_link{
             cursor: pointer;
             i {
                 font-size:10px;
             }
         }
         .arrow_comment_link.disabled {
             cursor: default;
             color: @grey5;
         }
     }
 
     .comment-next-link {
         display: inline-block;
 
         .arrow_comment_link{
             cursor: pointer;
             i {
                 font-size:10px;
             }
         }
         .arrow_comment_link.disabled {
             cursor: default;
             color: @grey5;
         }
     }
 
     .delete-comment {
         display: inline-block;
         color: @rcblue;
 
         &:hover {
             cursor: pointer;
         }
     }
 
     .text {
         clear: both;
         .border-radius(@border-radius);
         .box-sizing(border-box);
 
         .markdown-block p,
         .rst-block p {
             margin: .5em 0 !important;
           // TODO: lisa: This is needed because of other rst !important rules :[
         }
     }
 
     .pr-version {
         display: inline-block;
     }
     .pr-version-inline {
         display: inline-block;
     }
     .pr-version-num {
         font-size: 10px;
     }
 }
 
 @comment-padding: 5px;
 
 .general-comments {
     .comment-outdated {
         opacity: @comment-outdated-opacity;
     }
 }
 
 .inline-comments {
     border-radius: @border-radius;
     .comment {
         margin: 0;
         border-radius: @border-radius;
     }
     .comment-outdated {
         opacity: @comment-outdated-opacity;
     }
 
     .comment-inline {
         background: white;
         padding: @comment-padding @comment-padding;
         border: @comment-padding solid @grey6;
 
         .text {
             border: none;
         }
         .meta {
             border-bottom: 1px solid @grey6;
             margin: -5px 0px;
             line-height: 24px;
         }
     }
     .comment-selected {
         border-left: 6px solid @comment-highlight-color;
     }
     .comment-inline-form {
         padding: @comment-padding;
         display: none;
     }
     .cb-comment-add-button {
         margin: @comment-padding;
     }
      /* hide add comment button when form is open */
     .comment-inline-form-open ~ .cb-comment-add-button {
         display: none;
     }
     .comment-inline-form-open {
         display: block;
     }
      /* hide add comment button when form but no comments */
     .comment-inline-form:first-child + .cb-comment-add-button {
         display: none;
     }
      /* hide add comment button when no comments or form */
     .cb-comment-add-button:first-child {
         display: none;
     }
      /* hide add comment button when only comment is being deleted */
     .comment-deleting:first-child + .cb-comment-add-button {
         display: none;
     }
 }
 
 
 .show-outdated-comments {
     display: inline;
     color: @rcblue;
 }
 
 // Comment Form
 div.comment-form {
     margin-top: 20px;
 }
 
 .comment-form strong {
     display: block;
     margin-bottom: 15px;
 }
 
 .comment-form textarea {
     width: 100%;
     height: 100px;
     font-family: @text-monospace;
 }
 
 form.comment-form {
     margin-top: 10px;
     margin-left: 10px;
 }
 
 .comment-inline-form .comment-block-ta,
 .comment-form .comment-block-ta,
 .comment-form .preview-box {
     .border-radius(@border-radius);
     .box-sizing(border-box);
     background-color: white;
 }
 
 .comment-form-submit {
     margin-top: 5px;
     margin-left: 525px;
 }
 
 .file-comments {
     display: none;
 }
 
 .comment-form .preview-box.unloaded,
 .comment-inline-form .preview-box.unloaded {
     height: 50px;
     text-align: center;
     padding: 20px;
     background-color: white;
 }
 
 .comment-footer {
     position: relative;
     width: 100%;
     min-height: 42px;
 
     .status_box,
     .cancel-button {
         float: left;
         display: inline-block;
     }
 
     .status_box {
         margin-left: 10px;
     }
 
     .action-buttons {
         float: left;
         display: inline-block;
     }
 
     .action-buttons-extra {
         display: inline-block;
     }
 }
 
 .comment-form {
 
     .comment {
         margin-left: 10px;
     }
 
     .comment-help {
         color: @grey4;
         padding: 5px 0 5px 0;
     }
 
     .comment-title {
         padding: 5px 0 5px 0;
     }
 
     .comment-button {
         display: inline-block;
     }
 
     .comment-button-input {
         margin-right: 0;
     }
 
     .comment-footer {
         margin-bottom: 50px;
         margin-top: 10px;
     }
 }
 
 
 .comment-form-login {
     .comment-help {
         padding: 0.7em; //same as the button
     }
 
     div.clearfix {
         clear: both;
         width: 100%;
         display: block;
     }
 }
 
 .comment-version-select {
     margin: 0px;
     border-radius: inherit;
     border-color: @grey6;
     height: 20px;
 }
 
 .comment-type {
     margin: 0px;
     border-radius: inherit;
     border-color: @grey6;
 }
 
 .preview-box {
     min-height: 105px;
     margin-bottom: 15px;
     background-color: white;
     .border-radius(@border-radius);
     .box-sizing(border-box);
 }
 
 .add-another-button {
     margin-left: 10px;
     margin-top: 10px;
     margin-bottom: 10px;
 }
 
 .comment .buttons {
     float: right;
     margin: -1px 0px 0px 0px;
 }
 
 // Inline Comment Form
 .injected_diff .comment-inline-form,
 .comment-inline-form {
     background-color: white;
     margin-top: 10px;
     margin-bottom: 20px;
 }
 
 .inline-form {
     padding: 10px 7px;
 }
 
 .inline-form div {
     max-width: 100%;
 }
 
 .overlay {
     display: none;
     position: absolute;
     width: 100%;
     text-align: center;
     vertical-align: middle;
     font-size: 16px;
     background: none repeat scroll 0 0 white;
 
     &.submitting {
         display: block;
         opacity: 0.5;
         z-index: 100;
     }
 }
 .comment-inline-form .overlay.submitting .overlay-text {
     margin-top: 5%;
 }
 
 .comment-inline-form .clearfix,
 .comment-form .clearfix {
     .border-radius(@border-radius);
     margin: 0px;
 }
 
 .comment-inline-form .comment-footer {
     margin: 10px 0px 0px 0px;
 }
 
 .hide-inline-form-button {
     margin-left: 5px;
 }
 .comment-button .hide-inline-form {
     background: white;
 }
 
 .comment-area {
     padding: 6px 8px;
     border: 1px solid @grey5;
     .border-radius(@border-radius);
 
     .resolve-action {
         padding: 1px 0px 0px 6px;
     }
 
 }
 
 comment-area-text {
     color: @grey3;
 }
 
 .comment-area-header {
     height: 35px;
 }
 
 .comment-area-header .nav-links {
     display: flex;
     flex-flow: row wrap;
     -webkit-flex-flow: row wrap;
     width: 100%;
 }
 
 .comment-area-footer {
     min-height: 30px;
 }
 
 .comment-footer .toolbar {
 
 }
 
 .comment-attachment-uploader {
     border: 1px dashed white;
     border-radius: @border-radius;
     margin-top: -10px;
     line-height: 30px;
     &.dz-drag-hover {
         border-color: @grey3;
     }
 
     .dz-error-message {
         padding-top: 0;
     }
 }
 
 .comment-attachment-text {
     clear: both;
     font-size: 11px;
     color: #8F8F8F;
     width: 100%;
     .pick-attachment {
         color: #8F8F8F;
     }
     .pick-attachment:hover {
         color: @rcblue;
     }
 }
 
 .nav-links {
     padding: 0;
     margin: 0;
     list-style: none;
     height: auto;
     border-bottom: 1px solid @grey5;
 }
 .nav-links li {
     display: inline-block;
     list-style-type: none;
 }
 
 .nav-links li a.disabled {
     cursor: not-allowed;
 }
 
 .nav-links li.active a {
     border-bottom: 2px solid @rcblue;
     color: #000;
     font-weight: 600;
 }
 .nav-links li a {
     display: inline-block;
     padding: 0px 10px 5px 10px;
     margin-bottom: -1px;
     font-size: 14px;
     line-height: 28px;
     color: #8f8f8f;
     border-bottom: 2px solid transparent;
 }
 
 .toolbar-text {
     float: right;
     font-size: 11px;
     color: @grey4;
     text-align: right;
 
     a {
         color: @grey4;
     }
 }
 

rhodecode/public/js/src/rhodecode/codemirror.js

@@ -1,843 +1,850 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/
 
 /**
  * Code Mirror
  */
 // global code-mirror logger;, to enable run
 // Logger.get('CodeMirror').setLevel(Logger.DEBUG)
 
 cmLog = Logger.get('CodeMirror');
 cmLog.setLevel(Logger.OFF);
 
 
 //global cache for inline forms
 var userHintsCache = {};
 
 // global timer, used to cancel async loading
 var CodeMirrorLoadUserHintTimer;
 
 var escapeRegExChars = function(value) {
   return value.replace(/[\-\[\]\/\{\}\(\)\*\+\?\.\\\^\$\|]/g, "\\$&");
 };
 
 /**
  * Load hints from external source returns an array of objects in a format
  * that hinting lib requires
  * @returns {Array}
  */
 var CodeMirrorLoadUserHints = function(query, triggerHints) {
   cmLog.debug('Loading mentions users via AJAX');
   var _users = [];
   $.ajax({
     type: 'GET',
     data: {query: query},
     url: pyroutes.url('user_autocomplete_data'),
     headers: {'X-PARTIAL-XHR': true},
     async: true
   })
   .done(function(data) {
     var tmpl = '<img class="gravatar" src="{0}"/>{1}';
     $.each(data.suggestions, function(i) {
       var userObj = data.suggestions[i];
 
       if (userObj.username !== "default") {
         _users.push({
           text: userObj.username + " ",
           org_text: userObj.username,
           displayText: userObj.value_display, // search that field
           // internal caches
           _icon_link: userObj.icon_link,
           _text: userObj.value_display,
 
           render: function(elt, data, completion) {
             var el = document.createElement('div');
             el.className = "CodeMirror-hint-entry";
             el.innerHTML = tmpl.format(
                 completion._icon_link, completion._text);
             elt.appendChild(el);
           }
         });
       }
     });
     cmLog.debug('Mention users loaded');
     // set to global cache
     userHintsCache[query] = _users;
     triggerHints(userHintsCache[query]);
   })
   .fail(function(data, textStatus, xhr) {
       alert("error processing request. \n" +
             "Error code {0} ({1}).".format(data.status, data.statusText));
   });
 };
 
 /**
  * filters the results based on the current context
  * @param users
  * @param context
  * @returns {Array}
  */
 var CodeMirrorFilterUsers = function(users, context) {
   var MAX_LIMIT = 10;
   var filtered_users = [];
   var curWord = context.string;
 
   cmLog.debug('Filtering users based on query:', curWord);
   $.each(users, function(i) {
     var match = users[i];
     var searchText = match.displayText;
 
     if (!curWord ||
         searchText.toLowerCase().lastIndexOf(curWord) !== -1) {
       // reset state
       match._text = match.displayText;
       if (curWord) {
         // do highlighting
         var pattern = '(' + escapeRegExChars(curWord) + ')';
         match._text = searchText.replace(
             new RegExp(pattern, 'gi'), '<strong>$1<\/strong>');
       }
 
       filtered_users.push(match);
     }
     // to not return to many results, use limit of filtered results
     if (filtered_users.length > MAX_LIMIT) {
       return false;
     }
   });
 
   return filtered_users;
 };
 
 var CodeMirrorMentionHint = function(editor, callback, options) {
   var cur = editor.getCursor();
   var curLine = editor.getLine(cur.line).slice(0, cur.ch);
 
   // match on @ +1char
   var tokenMatch = new RegExp(
       '(^@| @)([a-zA-Z0-9]{1}[a-zA-Z0-9\-\_\.]*)$').exec(curLine);
 
   var tokenStr = '';
   if (tokenMatch !== null && tokenMatch.length > 0){
     tokenStr = tokenMatch[0].strip();
   } else {
     // skip if we didn't match our token
     return;
   }
 
   var context = {
     start: (cur.ch - tokenStr.length) + 1,
     end: cur.ch,
     string: tokenStr.slice(1),
     type: null
   };
 
   // case when we put the @sign in fron of a string,
   // eg <@ we put it here>sometext then we need to prepend to text
   if (context.end > cur.ch) {
     context.start = context.start + 1; // we add to the @ sign
     context.end = cur.ch; // don't eat front part just append
     context.string = context.string.slice(1, cur.ch - context.start);
   }
 
   cmLog.debug('Mention context', context);
 
   var triggerHints = function(userHints){
     return callback({
       list: CodeMirrorFilterUsers(userHints, context),
       from: CodeMirror.Pos(cur.line, context.start),
       to: CodeMirror.Pos(cur.line, context.end)
     });
   };
 
   var queryBasedHintsCache = undefined;
   // if we have something in the cache, try to fetch the query based cache
   if (userHintsCache !== {}){
     queryBasedHintsCache = userHintsCache[context.string];
   }
 
   if (queryBasedHintsCache !== undefined) {
     cmLog.debug('Users loaded from cache');
     triggerHints(queryBasedHintsCache);
   } else {
     // this takes care for async loading, and then displaying results
     // and also propagates the userHintsCache
     window.clearTimeout(CodeMirrorLoadUserHintTimer);
     CodeMirrorLoadUserHintTimer = setTimeout(function() {
       CodeMirrorLoadUserHints(context.string, triggerHints);
     }, 300);
   }
 };
 
 var CodeMirrorCompleteAfter = function(cm, pred) {
   var options = {
     completeSingle: false,
     async: true,
     closeOnUnfocus: true
   };
   var cur = cm.getCursor();
   setTimeout(function() {
     if (!cm.state.completionActive) {
       cmLog.debug('Trigger mentions hinting');
       CodeMirror.showHint(cm, CodeMirror.hint.mentions, options);
     }
   }, 100);
 
   // tell CodeMirror we didn't handle the key
   // trick to trigger on a char but still complete it
   return CodeMirror.Pass;
 };
 
 var initCodeMirror = function(textAreadId, resetUrl, focus, options) {
   if (textAreadId.substr(0,1) === "#"){
     var ta = $(textAreadId).get(0);
   }else {
     var ta = $('#' + textAreadId).get(0);
   }
 
   if (focus === undefined) {
       focus = true;
   }
 
   // default options
   var codeMirrorOptions = {
     mode: "null",
     lineNumbers: true,
     indentUnit: 4,
     autofocus: focus
   };
 
   if (options !== undefined) {
     // extend with custom options
     codeMirrorOptions = $.extend(true, codeMirrorOptions, options);
   }
 
   var myCodeMirror = CodeMirror.fromTextArea(ta, codeMirrorOptions);
 
   $('#reset').on('click', function(e) {
     window.location = resetUrl;
   });
 
   return myCodeMirror;
 };
 
 
 var initMarkupCodeMirror = function(textAreadId, focus, options) {
   var initialHeight = 100;
 
   var ta = $(textAreadId).get(0);
   if (focus === undefined) {
       focus = true;
   }
 
   // default options
   var codeMirrorOptions = {
     lineNumbers: false,
     indentUnit: 4,
     viewportMargin: 30,
     // this is a trick to trigger some logic behind codemirror placeholder
     // it influences styling and behaviour.
     placeholder: " ",
     lineWrapping: true,
     autofocus: focus
   };
 
   if (options !== undefined) {
     // extend with custom options
     codeMirrorOptions = $.extend(true, codeMirrorOptions, options);
   }
 
   var cm = CodeMirror.fromTextArea(ta, codeMirrorOptions);
   cm.setSize(null, initialHeight);
   cm.setOption("mode", DEFAULT_RENDERER);
   CodeMirror.autoLoadMode(cm, DEFAULT_RENDERER); // load rst or markdown mode
   cmLog.debug('Loading codemirror mode', DEFAULT_RENDERER);
 
   // start listening on changes to make auto-expanded editor
   cm.on("change", function (instance, changeObj) {
     var height = initialHeight;
     var lines = instance.lineCount();
     if (lines > 6 && lines < 20) {
       height = "auto";
     } else if (lines >= 20) {
       height = 20 * 15;
     }
     instance.setSize(null, height);
 
     // detect if the change was trigger by auto desc, or user input
     var changeOrigin = changeObj.origin;
 
     if (changeOrigin === "setValue") {
         cmLog.debug('Change triggered by setValue');
     }
     else {
         cmLog.debug('user triggered change !');
         // set special marker to indicate user has created an input.
         instance._userDefinedValue = true;
     }
 
   });
 
   return cm;
 };
 
 
 var initCommentBoxCodeMirror = function(CommentForm, textAreaId, triggerActions){
   var initialHeight = 100;
 
   if (typeof userHintsCache === "undefined") {
     userHintsCache = {};
     cmLog.debug('Init empty cache for mentions');
   }
   if (!$(textAreaId).get(0)) {
     cmLog.debug('Element for textarea not found', textAreaId);
     return;
   }
     /**
      * Filter action based on typed in text
      * @param actions
      * @param context
      * @returns {Array}
      */
 
     var filterActions = function(actions, context){
 
       var MAX_LIMIT = 10;
       var filtered_actions = [];
       var curWord = context.string;
 
       cmLog.debug('Filtering actions based on query:', curWord);
       $.each(actions, function(i) {
         var match = actions[i];
         var searchText = match.searchText;
 
         if (!curWord ||
           searchText.toLowerCase().lastIndexOf(curWord) !== -1) {
           // reset state
           match._text = match.displayText;
           if (curWord) {
             // do highlighting
             var pattern = '(' + escapeRegExChars(curWord) + ')';
             match._text = searchText.replace(
               new RegExp(pattern, 'gi'), '<strong>$1<\/strong>');
           }
 
           filtered_actions.push(match);
         }
         // to not return to many results, use limit of filtered results
         if (filtered_actions.length > MAX_LIMIT) {
             return false;
         }
       });
 
       return filtered_actions;
     };
 
     var submitForm = function(cm, pred) {
-      $(cm.display.input.textarea.form).submit();
+      $(cm.display.input.textarea.form).find('.submit-comment-action').click();
+      return CodeMirror.Pass;
+    };
+
+    var submitFormAsDraft = function(cm, pred) {
+      $(cm.display.input.textarea.form).find('.submit-draft-action').click();
       return CodeMirror.Pass;
     };
 
     var completeActions = function(actions){
 
         var registeredActions = [];
         var allActions = [
         {
           text: "approve",
           searchText: "status approved",
           displayText: _gettext('Set status to Approved'),
           hint: function(CodeMirror, data, completion) {
             CodeMirror.replaceRange("", completion.from || data.from,
                         completion.to || data.to, "complete");
             $(CommentForm.statusChange).select2("val", 'approved').trigger('change');
           },
           render: function(elt, data, completion) {
             var el = document.createElement('i');
 
             el.className = "icon-circle review-status-approved";
             elt.appendChild(el);
 
             el = document.createElement('span');
             el.innerHTML = completion.displayText;
             elt.appendChild(el);
           }
         },
         {
           text: "reject",
           searchText: "status rejected",
           displayText: _gettext('Set status to Rejected'),
           hint: function(CodeMirror, data, completion) {
               CodeMirror.replaceRange("", completion.from || data.from,
                           completion.to || data.to, "complete");
               $(CommentForm.statusChange).select2("val", 'rejected').trigger('change');
           },
           render: function(elt, data, completion) {
               var el = document.createElement('i');
               el.className = "icon-circle review-status-rejected";
               elt.appendChild(el);
 
               el = document.createElement('span');
               el.innerHTML = completion.displayText;
               elt.appendChild(el);
           }
         },
         {
           text: "as_todo",
           searchText: "todo comment",
           displayText: _gettext('TODO comment'),
           hint: function(CodeMirror, data, completion) {
               CodeMirror.replaceRange("", completion.from || data.from,
                           completion.to || data.to, "complete");
 
               $(CommentForm.commentType).val('todo');
           },
           render: function(elt, data, completion) {
               var el = document.createElement('div');
               el.className = "pull-left";
               elt.appendChild(el);
 
               el = document.createElement('span');
               el.innerHTML = completion.displayText;
               elt.appendChild(el);
           }
         },
         {
           text: "as_note",
           searchText: "note comment",
           displayText: _gettext('Note Comment'),
           hint: function(CodeMirror, data, completion) {
               CodeMirror.replaceRange("", completion.from || data.from,
                           completion.to || data.to, "complete");
 
               $(CommentForm.commentType).val('note');
           },
           render: function(elt, data, completion) {
               var el = document.createElement('div');
               el.className = "pull-left";
               elt.appendChild(el);
 
               el = document.createElement('span');
               el.innerHTML = completion.displayText;
               elt.appendChild(el);
           }
         }
         ];
 
         $.each(allActions, function(index, value){
             var actionData = allActions[index];
             if (actions.indexOf(actionData['text']) != -1) {
                 registeredActions.push(actionData);
             }
         });
 
         return function(cm, pred) {
             var cur = cm.getCursor();
             var options = {
                 closeOnUnfocus: true,
                 registeredActions: registeredActions
             };
             setTimeout(function() {
                 if (!cm.state.completionActive) {
                     cmLog.debug('Trigger actions hinting');
                     CodeMirror.showHint(cm, CodeMirror.hint.actions, options);
                 }
             }, 100);
 
             // tell CodeMirror we didn't handle the key
             // trick to trigger on a char but still complete it
             return CodeMirror.Pass;
         }
     };
 
     var extraKeys = {
       "'@'": CodeMirrorCompleteAfter,
       Tab: function(cm) {
         // space indent instead of TABS
         var spaces = new Array(cm.getOption("indentUnit") + 1).join(" ");
         cm.replaceSelection(spaces);
       }
     };
     // submit form on Meta-Enter
     if (OSType === "mac") {
       extraKeys["Cmd-Enter"] = submitForm;
+      extraKeys["Shift-Cmd-Enter"] = submitFormAsDraft;
     }
     else {
       extraKeys["Ctrl-Enter"] = submitForm;
+      extraKeys["Shift-Ctrl-Enter"] = submitFormAsDraft;
     }
 
     if (triggerActions) {
       // register triggerActions for this instance
       extraKeys["'/'"] = completeActions(triggerActions);
     }
 
     var cm = CodeMirror.fromTextArea($(textAreaId).get(0), {
       lineNumbers: false,
       indentUnit: 4,
       viewportMargin: 30,
       // this is a trick to trigger some logic behind codemirror placeholder
       // it influences styling and behaviour.
       placeholder: " ",
       extraKeys: extraKeys,
       lineWrapping: true
     });
 
     cm.setSize(null, initialHeight);
     cm.setOption("mode", DEFAULT_RENDERER);
     CodeMirror.autoLoadMode(cm, DEFAULT_RENDERER); // load rst or markdown mode
     cmLog.debug('Loading codemirror mode', DEFAULT_RENDERER);
 
     // start listening on changes to make auto-expanded editor
     cm.on("change", function (self) {
       var height = initialHeight;
       var lines = self.lineCount();
       if (lines > 6 && lines < 20) {
         height = "auto";
       } else if (lines >= 20) {
         height = 20 * 15;
       }
       self.setSize(null, height);
     });
 
     var actionHint = function(editor, options) {
 
       var cur = editor.getCursor();
       var curLine = editor.getLine(cur.line).slice(0, cur.ch);
 
       // match  only on /+1 character minimum
       var tokenMatch = new RegExp('(^/\|/\)([a-zA-Z]*)$').exec(curLine);
 
       var tokenStr = '';
       if (tokenMatch !== null && tokenMatch.length > 0){
         tokenStr = tokenMatch[2].strip();
       }
 
       var context = {
         start: (cur.ch - tokenStr.length) - 1,
         end: cur.ch,
         string: tokenStr,
         type: null
       };
 
       return {
         list: filterActions(options.registeredActions, context),
         from: CodeMirror.Pos(cur.line, context.start),
         to: CodeMirror.Pos(cur.line, context.end)
       };
 
     };
     CodeMirror.registerHelper("hint", "mentions", CodeMirrorMentionHint);
     CodeMirror.registerHelper("hint", "actions", actionHint);
     return cm;
 };
 
 var setCodeMirrorMode = function(codeMirrorInstance, mode) {
   CodeMirror.autoLoadMode(codeMirrorInstance, mode);
   codeMirrorInstance.setOption("mode", mode);
 };
 
 var setCodeMirrorLineWrap = function(codeMirrorInstance, line_wrap) {
   codeMirrorInstance.setOption("lineWrapping", line_wrap);
 };
 
 var setCodeMirrorModeFromSelect = function(
   targetSelect, targetFileInput, codeMirrorInstance, callback){
 
   $(targetSelect).on('change', function(e) {
     cmLog.debug('codemirror select2 mode change event !');
     var selected = e.currentTarget;
     var node = selected.options[selected.selectedIndex];
     var mimetype = node.value;
     cmLog.debug('picked mimetype', mimetype);
     var new_mode = $(node).attr('mode');
     setCodeMirrorMode(codeMirrorInstance, new_mode);
     cmLog.debug('set new mode', new_mode);
 
     //propose filename from picked mode
     cmLog.debug('setting mimetype', mimetype);
     var proposed_ext = getExtFromMimeType(mimetype);
     cmLog.debug('file input', $(targetFileInput).val());
     var file_data = getFilenameAndExt($(targetFileInput).val());
     var filename = file_data.filename || 'filename1';
     $(targetFileInput).val(filename + proposed_ext);
     cmLog.debug('proposed file', filename + proposed_ext);
 
 
     if (typeof(callback) === 'function') {
       try {
         cmLog.debug('running callback', callback);
         callback(filename, mimetype, new_mode);
       } catch (err) {
         console.log('failed to run callback', callback, err);
       }
     }
     cmLog.debug('finish iteration...');
   });
 };
 
 var setCodeMirrorModeFromInput = function(
   targetSelect, targetFileInput, codeMirrorInstance, callback) {
 
   // on type the new filename set mode
   $(targetFileInput).on('keyup', function(e) {
     var file_data = getFilenameAndExt(this.value);
     if (file_data.ext === null) {
       return;
     }
 
     var mimetypes = getMimeTypeFromExt(file_data.ext, true);
     cmLog.debug('mimetype from file', file_data, mimetypes);
     var detected_mode;
     var detected_option;
     for (var i in mimetypes) {
       var mt = mimetypes[i];
       if (!detected_mode) {
         detected_mode = detectCodeMirrorMode(this.value, mt);
       }
 
       if (!detected_option) {
         cmLog.debug('#mimetype option[value="{0}"]'.format(mt));
         if ($(targetSelect).find('option[value="{0}"]'.format(mt)).length) {
           detected_option = mt;
         }
       }
     }
 
     cmLog.debug('detected mode', detected_mode);
     cmLog.debug('detected option', detected_option);
     if (detected_mode && detected_option){
 
       $(targetSelect).select2("val", detected_option);
       setCodeMirrorMode(codeMirrorInstance, detected_mode);
 
       if(typeof(callback) === 'function'){
         try{
           cmLog.debug('running callback', callback);
           var filename = file_data.filename + "." + file_data.ext;
           callback(filename, detected_option, detected_mode);
         }catch (err){
           console.log('failed to run callback', callback, err);
         }
       }
     }
 
   });
 };
 
 var fillCodeMirrorOptions = function(targetSelect) {
   //inject new modes, based on codeMirrors modeInfo object
   var modes_select = $(targetSelect);
   for (var i = 0; i < CodeMirror.modeInfo.length; i++) {
     var m = CodeMirror.modeInfo[i];
     var opt = new Option(m.name, m.mime);
     $(opt).attr('mode', m.mode);
     modes_select.append(opt);
   }
 };
 
 
  /* markup form */
 (function(mod) {
 
     if (typeof exports == "object" && typeof module == "object") {
         // CommonJS
         module.exports = mod();
     }
     else {
         // Plain browser env
         (this || window).MarkupForm = mod();
     }
 
 })(function() {
     "use strict";
 
     function MarkupForm(textareaId) {
         if (!(this instanceof MarkupForm)) {
             return new MarkupForm(textareaId);
         }
 
         // bind the element instance to our Form
         $('#' + textareaId).get(0).MarkupForm = this;
 
         this.withSelectorId = function(selector) {
             var selectorId = textareaId;
             return selector + '_' + selectorId;
         };
 
         this.previewButton = this.withSelectorId('#preview-btn');
         this.previewContainer = this.withSelectorId('#preview-container');
 
         this.previewBoxSelector = this.withSelectorId('#preview-box');
 
         this.editButton = this.withSelectorId('#edit-btn');
         this.editContainer = this.withSelectorId('#edit-container');
 
         this.cmBox = textareaId;
         this.cm = initMarkupCodeMirror('#' + textareaId);
 
         this.previewUrl = pyroutes.url('markup_preview');
 
         // FUNCTIONS and helpers
         var self = this;
 
         this.getCmInstance = function(){
             return this.cm
         };
 
         this.setPlaceholder = function(placeholder) {
             var cm = this.getCmInstance();
             if (cm){
                 cm.setOption('placeholder', placeholder);
             }
         };
 
         this.initStatusChangeSelector = function(){
             var formatChangeStatus = function(state, escapeMarkup) {
                 var originalOption = state.element;
                 var tmpl = '<i class="icon-circle review-status-{0}"></i><span>{1}</span>'.format($(originalOption).data('status'), escapeMarkup(state.text));
                 return tmpl
             };
             var formatResult = function(result, container, query, escapeMarkup) {
                 return formatChangeStatus(result, escapeMarkup);
             };
 
             var formatSelection = function(data, container, escapeMarkup) {
                 return formatChangeStatus(data, escapeMarkup);
             };
 
             $(this.submitForm).find(this.statusChange).select2({
                 placeholder: _gettext('Status Review'),
                 formatResult: formatResult,
                 formatSelection: formatSelection,
                 containerCssClass: "drop-menu status_box_menu",
                 dropdownCssClass: "drop-menu-dropdown",
                 dropdownAutoWidth: true,
                 minimumResultsForSearch: -1
             });
             $(this.submitForm).find(this.statusChange).on('change', function() {
                 var status = self.getCommentStatus();
 
                 if (status && !self.isInline()) {
                     $(self.submitButton).prop('disabled', false);
                 }
 
                 var placeholderText = _gettext('Comment text will be set automatically based on currently selected status ({0}) ...').format(status);
                 self.setPlaceholder(placeholderText)
             })
         };
 
         // reset the text area into it's original state
         this.resetMarkupFormState = function(content) {
             content = content || '';
 
             $(this.editContainer).show();
             $(this.editButton).parent().addClass('active');
 
             $(this.previewContainer).hide();
             $(this.previewButton).parent().removeClass('active');
 
             this.setActionButtonsDisabled(true);
             self.cm.setValue(content);
             self.cm.setOption("readOnly", false);
         };
 
         this.previewSuccessCallback = function(o) {
             $(self.previewBoxSelector).html(o);
             $(self.previewBoxSelector).removeClass('unloaded');
 
             // swap buttons, making preview active
             $(self.previewButton).parent().addClass('active');
             $(self.editButton).parent().removeClass('active');
 
             // unlock buttons
             self.setActionButtonsDisabled(false);
         };
 
         this.setActionButtonsDisabled = function(state) {
             $(this.editButton).prop('disabled', state);
             $(this.previewButton).prop('disabled', state);
         };
 
         // lock preview/edit/submit buttons on load, but exclude cancel button
         var excludeCancelBtn = true;
         this.setActionButtonsDisabled(true);
 
         // anonymous users don't have access to initialized CM instance
         if (this.cm !== undefined){
             this.cm.on('change', function(cMirror) {
                 if (cMirror.getValue() === "") {
                     self.setActionButtonsDisabled(true)
                 } else {
                     self.setActionButtonsDisabled(false)
                 }
             });
         }
 
         $(this.editButton).on('click', function(e) {
             e.preventDefault();
 
             $(self.previewButton).parent().removeClass('active');
             $(self.previewContainer).hide();
 
             $(self.editButton).parent().addClass('active');
             $(self.editContainer).show();
 
         });
 
         $(this.previewButton).on('click', function(e) {
             e.preventDefault();
             var text = self.cm.getValue();
 
             if (text === "") {
                 return;
             }
 
             var postData = {
                 'text': text,
                 'renderer': templateContext.visual.default_renderer,
                 'csrf_token': CSRF_TOKEN
             };
 
             // lock ALL buttons on preview
             self.setActionButtonsDisabled(true);
 
             $(self.previewBoxSelector).addClass('unloaded');
             $(self.previewBoxSelector).html(_gettext('Loading ...'));
 
             $(self.editContainer).hide();
             $(self.previewContainer).show();
 
             // by default we reset state of comment preserving the text
             var previewFailCallback = function(data){
                 alert(
                 "Error while submitting preview.\n" +
                 "Error code {0} ({1}).".format(data.status, data.statusText)
                 );
                 self.resetMarkupFormState(text)
             };
             _submitAjaxPOST(
                 self.previewUrl, postData, self.previewSuccessCallback,
                 previewFailCallback);
 
             $(self.previewButton).parent().addClass('active');
             $(self.editButton).parent().removeClass('active');
         });
 
     }
 
     return MarkupForm;
 });

rhodecode/public/js/src/rhodecode/comments.js

@@ -1,1298 +1,1349 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 firefoxAnchorFix = function() {
   // hack to make anchor links behave properly on firefox, in our inline
   // comments generation when comments are injected firefox is misbehaving
   // when jumping to anchor links
   if (location.href.indexOf('#') > -1) {
     location.href += '';
   }
 };
 
 var linkifyComments = function(comments) {
   var firstCommentId = null;
   if (comments) {
       firstCommentId = $(comments[0]).data('comment-id');
   }
 
   if (firstCommentId){
     $('#inline-comments-counter').attr('href', '#comment-' + firstCommentId);
   }
 };
 
 var bindToggleButtons = function() {
   $('.comment-toggle').on('click', function() {
         $(this).parent().nextUntil('tr.line').toggle('inline-comments');
   });
 };
 
 
 
 var _submitAjaxPOST = function(url, postData, successHandler, failHandler) {
     failHandler = failHandler || function() {};
     postData = toQueryString(postData);
     var request = $.ajax({
         url: url,
         type: 'POST',
         data: postData,
         headers: {'X-PARTIAL-XHR': true}
     })
     .done(function (data) {
         successHandler(data);
     })
     .fail(function (data, textStatus, errorThrown) {
         failHandler(data, textStatus, errorThrown)
     });
     return request;
 };
 
 
 
 
 /* Comment form for main and inline comments */
 (function(mod) {
 
     if (typeof exports == "object" && typeof module == "object") {
         // CommonJS
         module.exports = mod();
     }
     else {
         // Plain browser env
         (this || window).CommentForm = mod();
     }
 
 })(function() {
     "use strict";
 
     function CommentForm(formElement, commitId, pullRequestId, lineNo, initAutocompleteActions, resolvesCommentId, edit, comment_id) {
 
         if (!(this instanceof CommentForm)) {
             return new CommentForm(formElement, commitId, pullRequestId, lineNo, initAutocompleteActions, resolvesCommentId, edit, comment_id);
         }
 
         // bind the element instance to our Form
         $(formElement).get(0).CommentForm = this;
 
         this.withLineNo = function(selector) {
             var lineNo = this.lineNo;
             if (lineNo === undefined) {
                 return selector
             } else {
                 return selector + '_' + lineNo;
             }
         };
 
         this.commitId = commitId;
         this.pullRequestId = pullRequestId;
         this.lineNo = lineNo;
         this.initAutocompleteActions = initAutocompleteActions;
 
         this.previewButton = this.withLineNo('#preview-btn');
         this.previewContainer = this.withLineNo('#preview-container');
 
         this.previewBoxSelector = this.withLineNo('#preview-box');
 
         this.editButton = this.withLineNo('#edit-btn');
         this.editContainer = this.withLineNo('#edit-container');
         this.cancelButton = this.withLineNo('#cancel-btn');
         this.commentType = this.withLineNo('#comment_type');
 
         this.resolvesId = null;
         this.resolvesActionId = null;
 
         this.closesPr = '#close_pull_request';
 
         this.cmBox = this.withLineNo('#text');
         this.cm = initCommentBoxCodeMirror(this, this.cmBox, this.initAutocompleteActions);
 
         this.statusChange = this.withLineNo('#change_status');
 
         this.submitForm = formElement;
-        this.submitButton = $(this.submitForm).find('input[type="submit"]');
+
+        this.submitButton = $(this.submitForm).find('.submit-comment-action');
         this.submitButtonText = this.submitButton.val();
 
+        this.submitDraftButton = $(this.submitForm).find('.submit-draft-action');
+        this.submitDraftButtonText = this.submitDraftButton.val();
 
         this.previewUrl = pyroutes.url('repo_commit_comment_preview',
             {'repo_name': templateContext.repo_name,
              'commit_id': templateContext.commit_data.commit_id});
 
         if (edit){
-            this.submitButtonText = _gettext('Updated Comment');
+            this.submitDraftButton.hide();
+            this.submitButtonText = _gettext('Update Comment');
             $(this.commentType).prop('disabled', true);
             $(this.commentType).addClass('disabled');
             var editInfo =
                 '';
             $(editInfo).insertBefore($(this.editButton).parent());
         }
 
         if (resolvesCommentId){
             this.resolvesId = '#resolve_comment_{0}'.format(resolvesCommentId);
             this.resolvesActionId = '#resolve_comment_action_{0}'.format(resolvesCommentId);
             $(this.commentType).prop('disabled', true);
             $(this.commentType).addClass('disabled');
 
             // disable select
             setTimeout(function() {
                 $(self.statusChange).select2('readonly', true);
             }, 10);
 
             var resolvedInfo = (
                 '<li class="resolve-action">' +
                 '<input type="hidden" id="resolve_comment_{0}" name="resolve_comment_{0}" value="{0}">' +
                 '<button id="resolve_comment_action_{0}" class="resolve-text btn btn-sm" onclick="return Rhodecode.comments.submitResolution({0})">{1} #{0}</button>' +
                 '</li>'
             ).format(resolvesCommentId, _gettext('resolve comment'));
             $(resolvedInfo).insertAfter($(this.commentType).parent());
         }
 
         // based on commitId, or pullRequestId decide where do we submit
         // out data
         if (this.commitId){
             var pyurl = 'repo_commit_comment_create';
             if(edit){
                 pyurl = 'repo_commit_comment_edit';
             }
             this.submitUrl = pyroutes.url(pyurl,
                 {'repo_name': templateContext.repo_name,
                  'commit_id': this.commitId,
                  'comment_id': comment_id});
             this.selfUrl = pyroutes.url('repo_commit',
                 {'repo_name': templateContext.repo_name,
                  'commit_id': this.commitId});
 
         } else if (this.pullRequestId) {
             var pyurl = 'pullrequest_comment_create';
             if(edit){
                 pyurl = 'pullrequest_comment_edit';
             }
             this.submitUrl = pyroutes.url(pyurl,
                 {'repo_name': templateContext.repo_name,
                  'pull_request_id': this.pullRequestId,
                  'comment_id': comment_id});
             this.selfUrl = pyroutes.url('pullrequest_show',
                 {'repo_name': templateContext.repo_name,
                  'pull_request_id': this.pullRequestId});
 
         } else {
             throw new Error(
                 'CommentForm requires pullRequestId, or commitId to be specified.')
         }
 
         // FUNCTIONS and helpers
         var self = this;
 
         this.isInline = function(){
             return this.lineNo && this.lineNo != 'general';
         };
 
         this.getCmInstance = function(){
             return this.cm
         };
 
         this.setPlaceholder = function(placeholder) {
             var cm = this.getCmInstance();
             if (cm){
                 cm.setOption('placeholder', placeholder);
             }
         };
 
         this.getCommentStatus = function() {
           return $(this.submitForm).find(this.statusChange).val();
         };
+
         this.getCommentType = function() {
           return $(this.submitForm).find(this.commentType).val();
         };
 
+        this.getDraftState = function () {
+            var submitterElem = $(this.submitForm).find('input[type="submit"].submitter');
+            var data = $(submitterElem).data('isDraft');
+            return data
+        }
+
         this.getResolvesId = function() {
             return $(this.submitForm).find(this.resolvesId).val() || null;
         };
 
         this.getClosePr = function() {
             return $(this.submitForm).find(this.closesPr).val() || null;
         };
 
         this.markCommentResolved = function(resolvedCommentId){
             $('#comment-label-{0}'.format(resolvedCommentId)).find('.resolved').show();
             $('#comment-label-{0}'.format(resolvedCommentId)).find('.resolve').hide();
         };
 
         this.isAllowedToSubmit = function() {
-          return !$(this.submitButton).prop('disabled');
+            var commentDisabled = $(this.submitButton).prop('disabled');
+            var draftDisabled = $(this.submitDraftButton).prop('disabled');
+            return !commentDisabled && !draftDisabled;
         };
 
         this.initStatusChangeSelector = function(){
             var formatChangeStatus = function(state, escapeMarkup) {
                 var originalOption = state.element;
                 var tmpl = '<i class="icon-circle review-status-{0}"></i><span>{1}</span>'.format($(originalOption).data('status'), escapeMarkup(state.text));
                 return tmpl
             };
             var formatResult = function(result, container, query, escapeMarkup) {
                 return formatChangeStatus(result, escapeMarkup);
             };
 
             var formatSelection = function(data, container, escapeMarkup) {
                 return formatChangeStatus(data, escapeMarkup);
             };
 
             $(this.submitForm).find(this.statusChange).select2({
                 placeholder: _gettext('Status Review'),
                 formatResult: formatResult,
                 formatSelection: formatSelection,
                 containerCssClass: "drop-menu status_box_menu",
                 dropdownCssClass: "drop-menu-dropdown",
                 dropdownAutoWidth: true,
                 minimumResultsForSearch: -1
             });
+
             $(this.submitForm).find(this.statusChange).on('change', function() {
                 var status = self.getCommentStatus();
 
                 if (status && !self.isInline()) {
                     $(self.submitButton).prop('disabled', false);
+                    $(self.submitDraftButton).prop('disabled', false);
                 }
 
                 var placeholderText = _gettext('Comment text will be set automatically based on currently selected status ({0}) ...').format(status);
                 self.setPlaceholder(placeholderText)
             })
         };
 
         // reset the comment form into it's original state
         this.resetCommentFormState = function(content) {
             content = content || '';
 
             $(this.editContainer).show();
             $(this.editButton).parent().addClass('active');
 
             $(this.previewContainer).hide();
             $(this.previewButton).parent().removeClass('active');
 
             this.setActionButtonsDisabled(true);
             self.cm.setValue(content);
             self.cm.setOption("readOnly", false);
 
             if (this.resolvesId) {
                 // destroy the resolve action
                 $(this.resolvesId).parent().remove();
             }
             // reset closingPR flag
             $('.close-pr-input').remove();
 
             $(this.statusChange).select2('readonly', false);
         };
 
-        this.globalSubmitSuccessCallback = function(){
+        this.globalSubmitSuccessCallback = function(comment){
             // default behaviour is to call GLOBAL hook, if it's registered.
             if (window.commentFormGlobalSubmitSuccessCallback !== undefined){
-                commentFormGlobalSubmitSuccessCallback();
+                commentFormGlobalSubmitSuccessCallback(comment);
             }
         };
 
         this.submitAjaxPOST = function(url, postData, successHandler, failHandler) {
             return _submitAjaxPOST(url, postData, successHandler, failHandler);
         };
 
         // overwrite a submitHandler, we need to do it for inline comments
         this.setHandleFormSubmit = function(callback) {
             this.handleFormSubmit = callback;
         };
 
         // overwrite a submitSuccessHandler
         this.setGlobalSubmitSuccessCallback = function(callback) {
             this.globalSubmitSuccessCallback = callback;
         };
 
         // default handler for for submit for main comments
         this.handleFormSubmit = function() {
             var text = self.cm.getValue();
             var status = self.getCommentStatus();
             var commentType = self.getCommentType();
+            var isDraft = self.getDraftState();
             var resolvesCommentId = self.getResolvesId();
             var closePullRequest = self.getClosePr();
 
             if (text === "" && !status) {
                 return;
             }
 
             var excludeCancelBtn = false;
             var submitEvent = true;
             self.setActionButtonsDisabled(true, excludeCancelBtn, submitEvent);
             self.cm.setOption("readOnly", true);
 
             var postData = {
                 'text': text,
                 'changeset_status': status,
                 'comment_type': commentType,
                 'csrf_token': CSRF_TOKEN
             };
 
             if (resolvesCommentId) {
                 postData['resolves_comment_id'] = resolvesCommentId;
             }
 
             if (closePullRequest) {
                 postData['close_pull_request'] = true;
             }
 
             var submitSuccessCallback = function(o) {
                 // reload page if we change status for single commit.
                 if (status && self.commitId) {
                     location.reload(true);
                 } else {
                     $('#injected_page_comments').append(o.rendered_text);
                     self.resetCommentFormState();
                     timeagoActivate();
                     tooltipActivate();
 
                     // mark visually which comment was resolved
                     if (resolvesCommentId) {
                         self.markCommentResolved(resolvesCommentId);
                     }
                 }
 
                 // run global callback on submit
-                self.globalSubmitSuccessCallback();
+                self.globalSubmitSuccessCallback({draft: isDraft, comment_id: comment_id});
 
             };
             var submitFailCallback = function(jqXHR, textStatus, errorThrown) {
                 var prefix = "Error while submitting comment.\n"
                 var message = formatErrorMessage(jqXHR, textStatus, errorThrown, prefix);
                 ajaxErrorSwal(message);
                 self.resetCommentFormState(text);
             };
             self.submitAjaxPOST(
                 self.submitUrl, postData, submitSuccessCallback, submitFailCallback);
         };
 
         this.previewSuccessCallback = function(o) {
             $(self.previewBoxSelector).html(o);
             $(self.previewBoxSelector).removeClass('unloaded');
 
             // swap buttons, making preview active
             $(self.previewButton).parent().addClass('active');
             $(self.editButton).parent().removeClass('active');
 
             // unlock buttons
             self.setActionButtonsDisabled(false);
         };
 
         this.setActionButtonsDisabled = function(state, excludeCancelBtn, submitEvent) {
             excludeCancelBtn = excludeCancelBtn || false;
             submitEvent = submitEvent || false;
 
             $(this.editButton).prop('disabled', state);
             $(this.previewButton).prop('disabled', state);
 
             if (!excludeCancelBtn) {
                 $(this.cancelButton).prop('disabled', state);
             }
 
             var submitState = state;
             if (!submitEvent && this.getCommentStatus() && !self.isInline()) {
                 // if the value of commit review status is set, we allow
                 // submit button, but only on Main form, isInline means inline
                 submitState = false
             }
 
             $(this.submitButton).prop('disabled', submitState);
+            $(this.submitDraftButton).prop('disabled', submitState);
+
             if (submitEvent) {
+              var isDraft = self.getDraftState();
+
+              if (isDraft) {
+                $(this.submitDraftButton).val(_gettext('Saving Draft...'));
+              }  else {
               $(this.submitButton).val(_gettext('Submitting...'));
+              }
+
             } else {
               $(this.submitButton).val(this.submitButtonText);
+              $(this.submitDraftButton).val(this.submitDraftButtonText);
             }
 
         };
 
         // lock preview/edit/submit buttons on load, but exclude cancel button
         var excludeCancelBtn = true;
         this.setActionButtonsDisabled(true, excludeCancelBtn);
 
         // anonymous users don't have access to initialized CM instance
         if (this.cm !== undefined){
             this.cm.on('change', function(cMirror) {
                 if (cMirror.getValue() === "") {
                     self.setActionButtonsDisabled(true, excludeCancelBtn)
                 } else {
                     self.setActionButtonsDisabled(false, excludeCancelBtn)
                 }
             });
         }
 
         $(this.editButton).on('click', function(e) {
             e.preventDefault();
 
             $(self.previewButton).parent().removeClass('active');
             $(self.previewContainer).hide();
 
             $(self.editButton).parent().addClass('active');
             $(self.editContainer).show();
 
         });
 
         $(this.previewButton).on('click', function(e) {
             e.preventDefault();
             var text = self.cm.getValue();
 
             if (text === "") {
                 return;
             }
 
             var postData = {
                 'text': text,
                 'renderer': templateContext.visual.default_renderer,
                 'csrf_token': CSRF_TOKEN
             };
 
             // lock ALL buttons on preview
             self.setActionButtonsDisabled(true);
 
             $(self.previewBoxSelector).addClass('unloaded');
             $(self.previewBoxSelector).html(_gettext('Loading ...'));
 
             $(self.editContainer).hide();
             $(self.previewContainer).show();
 
             // by default we reset state of comment preserving the text
             var previewFailCallback = function(jqXHR, textStatus, errorThrown) {
                 var prefix = "Error while preview of comment.\n"
                 var message = formatErrorMessage(jqXHR, textStatus, errorThrown, prefix);
                 ajaxErrorSwal(message);
 
                 self.resetCommentFormState(text)
             };
             self.submitAjaxPOST(
                 self.previewUrl, postData, self.previewSuccessCallback,
                 previewFailCallback);
 
             $(self.previewButton).parent().addClass('active');
             $(self.editButton).parent().removeClass('active');
         });
 
         $(this.submitForm).submit(function(e) {
             e.preventDefault();
             var allowedToSubmit = self.isAllowedToSubmit();
             if (!allowedToSubmit){
                return false;
             }
+
             self.handleFormSubmit();
         });
 
     }
 
     return CommentForm;
 });
 
 /* selector for comment versions */
 var initVersionSelector = function(selector, initialData) {
 
     var formatResult = function(result, container, query, escapeMarkup) {
 
         return renderTemplate('commentVersion', {
             show_disabled: true,
             version: result.comment_version,
             user_name: result.comment_author_username,
             gravatar_url: result.comment_author_gravatar,
             size: 16,
             timeago_component: result.comment_created_on,
         })
     };
 
     $(selector).select2({
         placeholder: "Edited",
         containerCssClass: "drop-menu-comment-history",
         dropdownCssClass: "drop-menu-dropdown",
         dropdownAutoWidth: true,
         minimumResultsForSearch: -1,
         data: initialData,
         formatResult: formatResult,
     });
 
     $(selector).on('select2-selecting', function (e) {
         // hide the mast as we later do preventDefault()
         $("#select2-drop-mask").click();
         e.preventDefault();
         e.choice.action();
     });
 
     $(selector).on("select2-open", function() {
         timeagoActivate();
     });
 };
 
 /* comments controller */
 var CommentsController = function() {
   var mainComment = '#text';
   var self = this;
 
   this.cancelComment = function (node) {
       var $node = $(node);
       var edit = $(this).attr('edit');
       if (edit) {
           var $general_comments = null;
           var $inline_comments = $node.closest('div.inline-comments');
           if (!$inline_comments.length) {
               $general_comments = $('#comments');
               var $comment = $general_comments.parent().find('div.comment:hidden');
               // show hidden general comment form
               $('#cb-comment-general-form-placeholder').show();
           } else {
               var $comment = $inline_comments.find('div.comment:hidden');
           }
           $comment.show();
       }
       $node.closest('.comment-inline-form').remove();
       return false;
   };
 
   this.showVersion = function (comment_id, comment_history_id) {
 
        var historyViewUrl = pyroutes.url(
            'repo_commit_comment_history_view',
            {
                'repo_name': templateContext.repo_name,
                'commit_id': comment_id,
                'comment_history_id': comment_history_id,
            }
        );
        successRenderCommit = function (data) {
            SwalNoAnimation.fire({
                html: data,
                title: '',
            });
        };
        failRenderCommit = function () {
            SwalNoAnimation.fire({
                html: 'Error while loading comment history',
                title: '',
            });
        };
        _submitAjaxPOST(
            historyViewUrl, {'csrf_token': CSRF_TOKEN},
            successRenderCommit,
            failRenderCommit
        );
   };
 
   this.getLineNumber = function(node) {
       var $node = $(node);
       var lineNo = $node.closest('td').attr('data-line-no');
       if (lineNo === undefined && $node.data('commentInline')){
           lineNo = $node.data('commentLineNo')
       }
 
       return lineNo
   };
 
   this.scrollToComment = function(node, offset, outdated) {
     if (offset === undefined) {
       offset = 0;
     }
     var outdated = outdated || false;
     var klass = outdated ? 'div.comment-outdated' : 'div.comment-current';
 
     if (!node) {
       node = $('.comment-selected');
       if (!node.length) {
         node = $('comment-current')
       }
     }
 
     $wrapper = $(node).closest('div.comment');
 
     // show hidden comment when referenced.
     if (!$wrapper.is(':visible')){
         $wrapper.show();
     }
 
     $comment = $(node).closest(klass);
     $comments = $(klass);
 
     $('.comment-selected').removeClass('comment-selected');
 
     var nextIdx = $(klass).index($comment) + offset;
     if (nextIdx >= $comments.length) {
       nextIdx = 0;
     }
     var $next = $(klass).eq(nextIdx);
 
     var $cb = $next.closest('.cb');
     $cb.removeClass('cb-collapsed');
 
     var $filediffCollapseState = $cb.closest('.filediff').prev();
     $filediffCollapseState.prop('checked', false);
     $next.addClass('comment-selected');
     scrollToElement($next);
     return false;
   };
 
   this.nextComment = function(node) {
     return self.scrollToComment(node, 1);
   };
 
   this.prevComment = function(node) {
     return self.scrollToComment(node, -1);
   };
 
   this.nextOutdatedComment = function(node) {
     return self.scrollToComment(node, 1, true);
   };
 
   this.prevOutdatedComment = function(node) {
     return self.scrollToComment(node, -1, true);
   };
 
   this._deleteComment = function(node) {
       var $node = $(node);
       var $td = $node.closest('td');
       var $comment = $node.closest('.comment');
-      var comment_id = $comment.attr('data-comment-id');
+      var comment_id = $($comment).data('commentId');
+      var isDraft = $($comment).data('commentDraft');
       var url = AJAX_COMMENT_DELETE_URL.replace('__COMMENT_ID__', comment_id);
       var postData = {
         'csrf_token': CSRF_TOKEN
       };
 
       $comment.addClass('comment-deleting');
       $comment.hide('fast');
 
       var success = function(response) {
         $comment.remove();
 
         if (window.updateSticky !== undefined) {
             // potentially our comments change the active window size, so we
             // notify sticky elements
             updateSticky()
         }
 
-        if (window.refreshAllComments !== undefined) {
+        if (window.refreshAllComments !== undefined && !isDraft) {
           // if we have this handler, run it, and refresh all comments boxes
           refreshAllComments()
         }
         return false;
       };
 
       var failure = function(jqXHR, textStatus, errorThrown) {
         var prefix = "Error while deleting this comment.\n"
         var message = formatErrorMessage(jqXHR, textStatus, errorThrown, prefix);
         ajaxErrorSwal(message);
 
         $comment.show('fast');
         $comment.removeClass('comment-deleting');
         return false;
       };
       ajaxPOST(url, postData, success, failure);
 
 
 
   }
 
   this.deleteComment = function(node) {
     var $comment = $(node).closest('.comment');
     var comment_id = $comment.attr('data-comment-id');
 
     SwalNoAnimation.fire({
       title: 'Delete this comment?',
       icon: 'warning',
       showCancelButton: true,
       confirmButtonText: _gettext('Yes, delete comment #{0}!').format(comment_id),
 
     }).then(function(result) {
       if (result.value) {
         self._deleteComment(node);
       }
     })
   };
 
+  this._finalizeDrafts = function(commentIds) {
+    window.finalizeDrafts(commentIds)
+  }
+
+  this.finalizeDrafts = function(commentIds) {
+
+    SwalNoAnimation.fire({
+      title: _ngettext('Submit {0} draft comment', 'Submit {0} draft comments', commentIds.length).format(commentIds.length),
+      icon: 'warning',
+      showCancelButton: true,
+      confirmButtonText: _gettext('Yes, finalize drafts'),
+
+    }).then(function(result) {
+      if (result.value) {
+        self._finalizeDrafts(commentIds);
+      }
+    })
+  };
+
   this.toggleWideMode = function (node) {
       if ($('#content').hasClass('wrapper')) {
           $('#content').removeClass("wrapper");
           $('#content').addClass("wide-mode-wrapper");
           $(node).addClass('btn-success');
           return true
       } else {
           $('#content').removeClass("wide-mode-wrapper");
           $('#content').addClass("wrapper");
           $(node).removeClass('btn-success');
           return false
       }
 
   };
 
   this.toggleComments = function(node, show) {
     var $filediff = $(node).closest('.filediff');
     if (show === true) {
       $filediff.removeClass('hide-comments');
     } else if (show === false) {
       $filediff.find('.hide-line-comments').removeClass('hide-line-comments');
       $filediff.addClass('hide-comments');
     } else {
       $filediff.find('.hide-line-comments').removeClass('hide-line-comments');
       $filediff.toggleClass('hide-comments');
     }
 
     // since we change the height of the diff container that has anchor points for upper
     // sticky header, we need to tell it to re-calculate those
     if (window.updateSticky !== undefined) {
         // potentially our comments change the active window size, so we
         // notify sticky elements
         updateSticky()
     }
 
     return false;
   };
 
   this.toggleLineComments = function(node) {
     self.toggleComments(node, true);
     var $node = $(node);
     // mark outdated comments as visible before the toggle;
     $(node.closest('tr')).find('.comment-outdated').show();
     $node.closest('tr').toggleClass('hide-line-comments');
   };
 
   this.createCommentForm = function(formElement, lineno, placeholderText, initAutocompleteActions, resolvesCommentId, edit, comment_id){
       var pullRequestId = templateContext.pull_request_data.pull_request_id;
       var commitId = templateContext.commit_data.commit_id;
 
       var commentForm = new CommentForm(
           formElement, commitId, pullRequestId, lineno, initAutocompleteActions, resolvesCommentId, edit, comment_id);
       var cm = commentForm.getCmInstance();
 
       if (resolvesCommentId){
         placeholderText = _gettext('Leave a resolution comment, or click resolve button to resolve TODO comment #{0}').format(resolvesCommentId);
       }
 
       setTimeout(function() {
           // callbacks
           if (cm !== undefined) {
               commentForm.setPlaceholder(placeholderText);
               if (commentForm.isInline()) {
                 cm.focus();
                 cm.refresh();
               }
           }
       }, 10);
 
       // trigger scrolldown to the resolve comment, since it might be away
       // from the clicked
       if (resolvesCommentId){
         var actionNode = $(commentForm.resolvesActionId).offset();
 
         setTimeout(function() {
             if (actionNode) {
                 $('body, html').animate({scrollTop: actionNode.top}, 10);
             }
         }, 100);
       }
 
         // add dropzone support
         var insertAttachmentText = function (cm, attachmentName, attachmentStoreUrl, isRendered) {
             var renderer = templateContext.visual.default_renderer;
             if (renderer == 'rst') {
                 var attachmentUrl = '`#{0} <{1}>`_'.format(attachmentName, attachmentStoreUrl);
                 if (isRendered){
                     attachmentUrl = '\n.. image:: {0}'.format(attachmentStoreUrl);
                 }
             } else if (renderer == 'markdown') {
                 var attachmentUrl = '[{0}]({1})'.format(attachmentName, attachmentStoreUrl);
                 if (isRendered){
                     attachmentUrl = '!' + attachmentUrl;
                 }
             } else {
                 var attachmentUrl = '{}'.format(attachmentStoreUrl);
             }
             cm.replaceRange(attachmentUrl+'\n', CodeMirror.Pos(cm.lastLine()));
 
             return false;
         };
 
         //see: https://www.dropzonejs.com/#configuration
         var storeUrl = pyroutes.url('repo_commit_comment_attachment_upload',
             {'repo_name': templateContext.repo_name,
                      'commit_id': templateContext.commit_data.commit_id})
 
         var previewTmpl = $(formElement).find('.comment-attachment-uploader-template').get(0);
         if (previewTmpl !== undefined){
             var selectLink = $(formElement).find('.pick-attachment').get(0);
             $(formElement).find('.comment-attachment-uploader').dropzone({
                 url: storeUrl,
                 headers: {"X-CSRF-Token": CSRF_TOKEN},
                 paramName: function () {
                     return "attachment"
                 }, // The name that will be used to transfer the file
                 clickable: selectLink,
                 parallelUploads: 1,
                 maxFiles: 10,
                 maxFilesize: templateContext.attachment_store.max_file_size_mb,
                 uploadMultiple: false,
                 autoProcessQueue: true, // if false queue will not be processed automatically.
                 createImageThumbnails: false,
                 previewTemplate: previewTmpl.innerHTML,
 
                 accept: function (file, done) {
                     done();
                 },
                 init: function () {
 
                     this.on("sending", function (file, xhr, formData) {
                         $(formElement).find('.comment-attachment-uploader').find('.dropzone-text').hide();
                         $(formElement).find('.comment-attachment-uploader').find('.dropzone-upload').show();
                     });
 
                     this.on("success", function (file, response) {
                         $(formElement).find('.comment-attachment-uploader').find('.dropzone-text').show();
                         $(formElement).find('.comment-attachment-uploader').find('.dropzone-upload').hide();
 
                         var isRendered = false;
                         var ext = file.name.split('.').pop();
                         var imageExts = templateContext.attachment_store.image_ext;
                         if (imageExts.indexOf(ext) !== -1){
                             isRendered = true;
                         }
 
                         insertAttachmentText(cm, file.name, response.repo_fqn_access_path, isRendered)
                     });
 
                     this.on("error", function (file, errorMessage, xhr) {
                         $(formElement).find('.comment-attachment-uploader').find('.dropzone-upload').hide();
 
                         var error = null;
 
                         if (xhr !== undefined){
                             var httpStatus = xhr.status + " " + xhr.statusText;
                             if (xhr !== undefined && xhr.status >= 500) {
                                 error = httpStatus;
                             }
                         }
 
                         if (error === null) {
                             error = errorMessage.error || errorMessage || httpStatus;
                         }
                         $(file.previewElement).find('.dz-error-message').html('ERROR: {0}'.format(error));
 
                     });
                 }
             });
         }
       return commentForm;
   };
 
   this.createGeneralComment = function (lineNo, placeholderText, resolvesCommentId) {
 
       var tmpl = $('#cb-comment-general-form-template').html();
       tmpl = tmpl.format(null, 'general');
       var $form = $(tmpl);
 
       var $formPlaceholder = $('#cb-comment-general-form-placeholder');
       var curForm = $formPlaceholder.find('form');
       if (curForm){
           curForm.remove();
       }
       $formPlaceholder.append($form);
 
       var _form = $($form[0]);
       var autocompleteActions = ['approve', 'reject', 'as_note', 'as_todo'];
       var edit = false;
       var comment_id = null;
       var commentForm = this.createCommentForm(
           _form, lineNo, placeholderText, autocompleteActions, resolvesCommentId, edit, comment_id);
       commentForm.initStatusChangeSelector();
 
       return commentForm;
   };
 
   this.editComment = function(node) {
       var $node = $(node);
       var $comment = $(node).closest('.comment');
-      var comment_id = $comment.attr('data-comment-id');
+      var comment_id = $($comment).data('commentId');
+      var isDraft = $($comment).data('commentDraft');
       var $form = null
 
       var $comments = $node.closest('div.inline-comments');
       var $general_comments = null;
       var lineno = null;
 
       if($comments.length){
           // inline comments setup
           $form = $comments.find('.comment-inline-form');
           lineno = self.getLineNumber(node)
       }
       else{
           // general comments setup
           $comments = $('#comments');
           $form = $comments.find('.comment-inline-form');
           lineno = $comment[0].id
           $('#cb-comment-general-form-placeholder').hide();
       }
 
       this.edit = true;
 
       if (!$form.length) {
 
           var $filediff = $node.closest('.filediff');
           $filediff.removeClass('hide-comments');
           var f_path = $filediff.attr('data-f-path');
 
           // create a new HTML from template
 
           var tmpl = $('#cb-comment-inline-form-template').html();
           tmpl = tmpl.format(escapeHtml(f_path), lineno);
           $form = $(tmpl);
           $comment.after($form)
 
           var _form = $($form[0]).find('form');
           var autocompleteActions = ['as_note',];
           var commentForm = this.createCommentForm(
               _form, lineno, '', autocompleteActions, resolvesCommentId,
               this.edit, comment_id);
           var old_comment_text_binary = $comment.attr('data-comment-text');
           var old_comment_text = b64DecodeUnicode(old_comment_text_binary);
           commentForm.cm.setValue(old_comment_text);
           $comment.hide();
 
            $.Topic('/ui/plugins/code/comment_form_built').prepareOrPublish({
                form: _form,
                parent: $comments,
                lineno: lineno,
                f_path: f_path}
            );
 
            // set a CUSTOM submit handler for inline comments.
             commentForm.setHandleFormSubmit(function(o) {
               var text = commentForm.cm.getValue();
               var commentType = commentForm.getCommentType();
 
               if (text === "") {
                 return;
               }
 
               if (old_comment_text == text) {
                   SwalNoAnimation.fire({
                       title: 'Unable to edit comment',
                       html: _gettext('Comment body was not changed.'),
                   });
                   return;
               }
               var excludeCancelBtn = false;
               var submitEvent = true;
               commentForm.setActionButtonsDisabled(true, excludeCancelBtn, submitEvent);
               commentForm.cm.setOption("readOnly", true);
 
               // Read last version known
               var versionSelector = $('#comment_versions_{0}'.format(comment_id));
               var version = versionSelector.data('lastVersion');
 
               if (!version) {
                 version = 0;
               }
 
               var postData = {
                   'text': text,
                   'f_path': f_path,
                   'line': lineno,
                   'comment_type': commentType,
+                  'draft': isDraft,
                   'version': version,
                   'csrf_token': CSRF_TOKEN
               };
 
               var submitSuccessCallback = function(json_data) {
                 $form.remove();
                 $comment.show();
                 var postData = {
                     'text': text,
                     'renderer': $comment.attr('data-comment-renderer'),
                     'csrf_token': CSRF_TOKEN
                 };
 
                 /* Inject new edited version selector */
                 var updateCommentVersionDropDown = function () {
                     var versionSelectId = '#comment_versions_'+comment_id;
                     var preLoadVersionData = [
                         {
                             id: json_data['comment_version'],
                             text: "v{0}".format(json_data['comment_version']),
                             action: function () {
                                 Rhodecode.comments.showVersion(
                                     json_data['comment_id'],
                                     json_data['comment_history_id']
                                 )
                             },
                             comment_version: json_data['comment_version'],
                             comment_author_username: json_data['comment_author_username'],
                             comment_author_gravatar: json_data['comment_author_gravatar'],
                             comment_created_on: json_data['comment_created_on'],
                         },
                     ]
 
 
                     if ($(versionSelectId).data('select2')) {
                         var oldData = $(versionSelectId).data('select2').opts.data.results;
                         $(versionSelectId).select2("destroy");
                         preLoadVersionData = oldData.concat(preLoadVersionData)
                     }
 
                     initVersionSelector(versionSelectId, {results: preLoadVersionData});
 
                     $comment.attr('data-comment-text', utf8ToB64(text));
 
                     var versionSelector = $('#comment_versions_'+comment_id);
 
                     // set lastVersion so we know our last edit version
                     versionSelector.data('lastVersion', json_data['comment_version'])
                     versionSelector.parent().show();
                 }
                 updateCommentVersionDropDown();
 
                 // by default we reset state of comment preserving the text
                 var failRenderCommit = function(jqXHR, textStatus, errorThrown) {
                     var prefix = "Error while editing this comment.\n"
                     var message = formatErrorMessage(jqXHR, textStatus, errorThrown, prefix);
                     ajaxErrorSwal(message);
                 };
 
                 var successRenderCommit = function(o){
                     $comment.show();
                     $comment[0].lastElementChild.innerHTML = o;
                 };
 
                 var previewUrl = pyroutes.url(
                     'repo_commit_comment_preview',
              {'repo_name': templateContext.repo_name,
                     'commit_id': templateContext.commit_data.commit_id});
 
                 _submitAjaxPOST(
                     previewUrl, postData, successRenderCommit,
                     failRenderCommit
                 );
 
                 try {
                   var html = json_data.rendered_text;
                   var lineno = json_data.line_no;
                   var target_id = json_data.target_id;
 
                   $comments.find('.cb-comment-add-button').before(html);
 
                  //  run global callback on submit
-                  commentForm.globalSubmitSuccessCallback();
+                  commentForm.globalSubmitSuccessCallback({draft: isDraft, comment_id: comment_id});
 
                 } catch (e) {
                   console.error(e);
                 }
 
                 // re trigger the linkification of next/prev navigation
                 linkifyComments($('.inline-comment-injected'));
                 timeagoActivate();
                 tooltipActivate();
 
                 if (window.updateSticky !== undefined) {
                     // potentially our comments change the active window size, so we
                     // notify sticky elements
                     updateSticky()
                 }
 
-                if (window.refreshAllComments !== undefined) {
+                if (window.refreshAllComments !== undefined && !isDraft) {
                       // if we have this handler, run it, and refresh all comments boxes
                       refreshAllComments()
                 }
 
                 commentForm.setActionButtonsDisabled(false);
 
               };
 
               var submitFailCallback = function(jqXHR, textStatus, errorThrown) {
                   var prefix = "Error while editing comment.\n"
                   var message = formatErrorMessage(jqXHR, textStatus, errorThrown, prefix);
                   if (jqXHR.status == 409){
                     message = 'This comment was probably changed somewhere else. Please reload the content of this comment.'
                     ajaxErrorSwal(message, 'Comment version mismatch.');
                   } else {
                     ajaxErrorSwal(message);
                   }
 
                   commentForm.resetCommentFormState(text)
               };
               commentForm.submitAjaxPOST(
                   commentForm.submitUrl, postData,
                   submitSuccessCallback,
                   submitFailCallback);
             });
       }
 
       $form.addClass('comment-inline-form-open');
   };
 
   this.createComment = function(node, resolutionComment) {
       var resolvesCommentId = resolutionComment || null;
       var $node = $(node);
       var $td = $node.closest('td');
       var $form = $td.find('.comment-inline-form');
       this.edit = false;
 
       if (!$form.length) {
 
           var $filediff = $node.closest('.filediff');
           $filediff.removeClass('hide-comments');
           var f_path = $filediff.attr('data-f-path');
           var lineno = self.getLineNumber(node);
           // create a new HTML from template
           var tmpl = $('#cb-comment-inline-form-template').html();
           tmpl = tmpl.format(escapeHtml(f_path), lineno);
           $form = $(tmpl);
 
           var $comments = $td.find('.inline-comments');
           if (!$comments.length) {
             $comments = $(
               $('#cb-comments-inline-container-template').html());
             $td.append($comments);
           }
 
           $td.find('.cb-comment-add-button').before($form);
 
           var placeholderText = _gettext('Leave a comment on line {0}.').format(lineno);
           var _form = $($form[0]).find('form');
           var autocompleteActions = ['as_note', 'as_todo'];
           var comment_id=null;
           var commentForm = this.createCommentForm(
               _form, lineno, placeholderText, autocompleteActions, resolvesCommentId, this.edit, comment_id);
 
           $.Topic('/ui/plugins/code/comment_form_built').prepareOrPublish({
               form: _form,
               parent: $td[0],
               lineno: lineno,
               f_path: f_path}
           );
 
           // set a CUSTOM submit handler for inline comments.
           commentForm.setHandleFormSubmit(function(o) {
             var text = commentForm.cm.getValue();
             var commentType = commentForm.getCommentType();
             var resolvesCommentId = commentForm.getResolvesId();
+            var isDraft = commentForm.getDraftState();
 
             if (text === "") {
               return;
             }
 
             if (lineno === undefined) {
               alert('missing line !');
               return;
             }
             if (f_path === undefined) {
               alert('missing file path !');
               return;
             }
 
             var excludeCancelBtn = false;
             var submitEvent = true;
             commentForm.setActionButtonsDisabled(true, excludeCancelBtn, submitEvent);
             commentForm.cm.setOption("readOnly", true);
             var postData = {
                 'text': text,
                 'f_path': f_path,
                 'line': lineno,
                 'comment_type': commentType,
+                'draft': isDraft,
                 'csrf_token': CSRF_TOKEN
             };
             if (resolvesCommentId){
                 postData['resolves_comment_id'] = resolvesCommentId;
             }
 
             var submitSuccessCallback = function(json_data) {
               $form.remove();
               try {
                 var html = json_data.rendered_text;
                 var lineno = json_data.line_no;
                 var target_id = json_data.target_id;
 
                 $comments.find('.cb-comment-add-button').before(html);
 
                 //mark visually which comment was resolved
                 if (resolvesCommentId) {
                     commentForm.markCommentResolved(resolvesCommentId);
                 }
 
                 // run global callback on submit
-                commentForm.globalSubmitSuccessCallback();
+                commentForm.globalSubmitSuccessCallback({draft: isDraft, comment_id: comment_id});
 
               } catch (e) {
                 console.error(e);
               }
 
               // re trigger the linkification of next/prev navigation
               linkifyComments($('.inline-comment-injected'));
               timeagoActivate();
               tooltipActivate();
 
               if (window.updateSticky !== undefined) {
                   // potentially our comments change the active window size, so we
                   // notify sticky elements
                   updateSticky()
               }
 
-              if (window.refreshAllComments !== undefined) {
+              if (window.refreshAllComments !== undefined && !isDraft) {
                   // if we have this handler, run it, and refresh all comments boxes
                   refreshAllComments()
               }
 
               commentForm.setActionButtonsDisabled(false);
 
             };
             var submitFailCallback = function(jqXHR, textStatus, errorThrown) {
                 var prefix = "Error while submitting comment.\n"
                 var message = formatErrorMessage(jqXHR, textStatus, errorThrown, prefix);
                 ajaxErrorSwal(message);
                 commentForm.resetCommentFormState(text)
             };
             commentForm.submitAjaxPOST(
                 commentForm.submitUrl, postData, submitSuccessCallback, submitFailCallback);
           });
       }
 
       $form.addClass('comment-inline-form-open');
   };
 
   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.submitResolution = function(commentId){
     var form = $('#resolve_comment_{0}'.format(commentId)).closest('form');
     var commentForm = form.get(0).CommentForm;
 
     var cm = commentForm.getCmInstance();
     var renderer = templateContext.visual.default_renderer;
     if (renderer == 'rst'){
         var commentUrl = '`#{0} <{1}#comment-{0}>`_'.format(commentId, commentForm.selfUrl);
     } else if (renderer == 'markdown') {
         var commentUrl = '[#{0}]({1}#comment-{0})'.format(commentId, commentForm.selfUrl);
     } else {
         var commentUrl = '{1}#comment-{0}'.format(commentId, commentForm.selfUrl);
     }
 
     cm.setValue(_gettext('TODO from comment {0} was fixed.').format(commentUrl));
     form.submit();
     return false;
   };
 
 };

rhodecode/templates/base/base.mako

@@ -1,1254 +1,1262 b''
 ## -*- coding: utf-8 -*-
 
 <%!
     from rhodecode.lib import html_filters
 %>
 
 <%inherit file="root.mako"/>
 
 <%include file="/ejs_templates/templates.html"/>
 
 <div class="outerwrapper">
   <!-- HEADER -->
   <div class="header">
       <div id="header-inner" class="wrapper">
           <div id="logo">
               <div class="logo-wrapper">
                   <a href="${h.route_path('home')}"><img src="${h.asset('images/rhodecode-logo-white-60x60.png')}" alt="RhodeCode"/></a>
               </div>
               % if c.rhodecode_name:
                <div class="branding">
                    <a href="${h.route_path('home')}">${h.branding(c.rhodecode_name)}</a>
                </div>
               % endif
           </div>
           <!-- MENU BAR NAV -->
           ${self.menu_bar_nav()}
           <!-- END MENU BAR NAV -->
       </div>
   </div>
   ${self.menu_bar_subnav()}
   <!-- END HEADER -->
 
   <!-- CONTENT -->
   <div id="content" class="wrapper">
 
       <rhodecode-toast id="notifications"></rhodecode-toast>
 
       <div class="main">
           ${next.main()}
       </div>
 
   </div>
   <!-- END CONTENT -->
 
 </div>
 
 <!-- FOOTER -->
 <div id="footer">
    <div id="footer-inner" class="title wrapper">
        <div>
            <% sid = 'block' if request.GET.get('showrcid') else 'none' %>
 
            <p class="footer-link-right">
                <a class="grey-link-action" href="${h.route_path('home', _query={'showrcid': 1})}">
                RhodeCode
                % if c.visual.show_version:
                    ${c.rhodecode_version}
                % endif
                ${c.rhodecode_edition}
                </a> |
 
                % if c.visual.rhodecode_support_url:
                   <a class="grey-link-action" href="${c.visual.rhodecode_support_url}" target="_blank">${_('Support')}</a> |
                   <a class="grey-link-action" href="https://docs.rhodecode.com" target="_blank">${_('Documentation')}</a>
                % endif
 
            </p>
 
            <p class="server-instance" style="display:${sid}">
                ## display hidden instance ID if specially defined
                &copy; 2010-${h.datetime.today().year}, <a href="${h.route_url('rhodecode_official')}" target="_blank">RhodeCode GmbH</a>. All rights reserved.
                % if c.rhodecode_instanceid:
                    ${_('RhodeCode instance id: {}').format(c.rhodecode_instanceid)}
                % endif
            </p>
        </div>
    </div>
 </div>
 
 <!-- END FOOTER -->
 
 ### MAKO DEFS ###
 
 <%def name="menu_bar_subnav()">
 </%def>
 
 <%def name="breadcrumbs(class_='breadcrumbs')">
     <div class="${class_}">
     ${self.breadcrumbs_links()}
     </div>
 </%def>
 
 <%def name="admin_menu(active=None)">
 
   <div id="context-bar">
     <div class="wrapper">
       <div class="title">
         <div class="title-content">
           <div class="title-main">
             % if c.is_super_admin:
                 ${_('Super-admin Panel')}
             % else:
                 ${_('Delegated Admin Panel')}
             % endif
           </div>
         </div>
       </div>
 
     <ul id="context-pages" class="navigation horizontal-list">
 
         ## super-admin case
         % if c.is_super_admin:
           <li class="${h.is_active('audit_logs', active)}"><a href="${h.route_path('admin_audit_logs')}">${_('Admin audit logs')}</a></li>
           <li class="${h.is_active('repositories', active)}"><a href="${h.route_path('repos')}">${_('Repositories')}</a></li>
           <li class="${h.is_active('repository_groups', active)}"><a href="${h.route_path('repo_groups')}">${_('Repository groups')}</a></li>
           <li class="${h.is_active('users', active)}"><a href="${h.route_path('users')}">${_('Users')}</a></li>
           <li class="${h.is_active('user_groups', active)}"><a href="${h.route_path('user_groups')}">${_('User groups')}</a></li>
           <li class="${h.is_active('permissions', active)}"><a href="${h.route_path('admin_permissions_application')}">${_('Permissions')}</a></li>
           <li class="${h.is_active('authentication', active)}"><a href="${h.route_path('auth_home', traverse='')}">${_('Authentication')}</a></li>
           <li class="${h.is_active('integrations', active)}"><a href="${h.route_path('global_integrations_home')}">${_('Integrations')}</a></li>
           <li class="${h.is_active('defaults', active)}"><a href="${h.route_path('admin_defaults_repositories')}">${_('Defaults')}</a></li>
           <li class="${h.is_active('settings', active)}"><a href="${h.route_path('admin_settings')}">${_('Settings')}</a></li>
 
         ## delegated admin
         % elif c.is_delegated_admin:
            <%
            repositories=c.auth_user.repositories_admin or c.can_create_repo
            repository_groups=c.auth_user.repository_groups_admin or c.can_create_repo_group
            user_groups=c.auth_user.user_groups_admin or c.can_create_user_group
            %>
 
            %if repositories:
               <li class="${h.is_active('repositories', active)} local-admin-repos"><a href="${h.route_path('repos')}">${_('Repositories')}</a></li>
            %endif
            %if repository_groups:
               <li class="${h.is_active('repository_groups', active)} local-admin-repo-groups"><a href="${h.route_path('repo_groups')}">${_('Repository groups')}</a></li>
            %endif
            %if user_groups:
               <li class="${h.is_active('user_groups', active)} local-admin-user-groups"><a href="${h.route_path('user_groups')}">${_('User groups')}</a></li>
            %endif
         % endif
     </ul>
 
     </div>
     <div class="clear"></div>
   </div>
 </%def>
 
 <%def name="dt_info_panel(elements)">
     <dl class="dl-horizontal">
     %for dt, dd, title, show_items in elements:
       <dt>${dt}:</dt>
       <dd title="${h.tooltip(title)}">
       %if callable(dd):
           ## allow lazy evaluation of elements
           ${dd()}
       %else:
           ${dd}
       %endif
       %if show_items:
           <span class="btn-collapse" data-toggle="item-${h.md5_safe(dt)[:6]}-details">${_('Show More')} </span>
       %endif
       </dd>
 
       %if show_items:
           <div class="collapsable-content" data-toggle="item-${h.md5_safe(dt)[:6]}-details" style="display: none">
           %for item in show_items:
               <dt></dt>
               <dd>${item}</dd>
           %endfor
           </div>
       %endif
 
     %endfor
     </dl>
 </%def>
 
 <%def name="tr_info_entry(element)">
     <% key, val, title, show_items = element %>
 
     <tr>
         <td style="vertical-align: top">${key}</td>
         <td title="${h.tooltip(title)}">
           %if callable(val):
               ## allow lazy evaluation of elements
               ${val()}
           %else:
               ${val}
           %endif
           %if show_items:
               <div class="collapsable-content" data-toggle="item-${h.md5_safe(val)[:6]}-details" style="display: none">
               % for item in show_items:
                   <dt></dt>
                   <dd>${item}</dd>
               % endfor
               </div>
           %endif
         </td>
         <td style="vertical-align: top">
           %if show_items:
               <span class="btn-collapse" data-toggle="item-${h.md5_safe(val)[:6]}-details">${_('Show More')} </span>
           %endif
         </td>
     </tr>
 
 </%def>
 
 <%def name="gravatar(email, size=16, tooltip=False, tooltip_alt=None, user=None, extra_class=None)">
   <%
     if size > 16:
         gravatar_class = ['gravatar','gravatar-large']
     else:
         gravatar_class = ['gravatar']
 
     data_hovercard_url = ''
     data_hovercard_alt = tooltip_alt.replace('<', '&lt;').replace('>', '&gt;') if tooltip_alt else ''
 
     if tooltip:
         gravatar_class += ['tooltip-hovercard']
     if extra_class:
         gravatar_class += extra_class
     if tooltip and user:
         if user.username == h.DEFAULT_USER:
             gravatar_class.pop(-1)
         else:
             data_hovercard_url = request.route_path('hovercard_user', user_id=getattr(user, 'user_id', ''))
     gravatar_class = ' '.join(gravatar_class)
 
   %>
   <%doc>
     TODO: johbo: For now we serve double size images to make it smooth
     for retina. This is how it worked until now. Should be replaced
     with a better solution at some point.
   </%doc>
 
   <img class="${gravatar_class}" height="${size}" width="${size}" data-hovercard-url="${data_hovercard_url}" data-hovercard-alt="${data_hovercard_alt}" src="${h.gravatar_url(email, size * 2)}" />
 </%def>
 
 
 <%def name="gravatar_with_user(contact, size=16, show_disabled=False, tooltip=False, _class='rc-user')">
   <%
       email = h.email_or_none(contact)
       rc_user = h.discover_user(contact)
   %>
 
   <div class="${_class}">
     ${self.gravatar(email, size, tooltip=tooltip, tooltip_alt=contact, user=rc_user)}
     <span class="${('user user-disabled' if show_disabled else 'user')}">
         ${h.link_to_user(rc_user or contact)}
     </span>
   </div>
 </%def>
 
 
 <%def name="user_group_icon(user_group=None, size=16, tooltip=False)">
   <%
     if (size > 16):
         gravatar_class = 'icon-user-group-alt'
     else:
         gravatar_class = 'icon-user-group-alt'
 
     if tooltip:
         gravatar_class += ' tooltip-hovercard'
 
     data_hovercard_url = request.route_path('hovercard_user_group', user_group_id=user_group.users_group_id)
   %>
   <%doc>
     TODO: johbo: For now we serve double size images to make it smooth
     for retina. This is how it worked until now. Should be replaced
     with a better solution at some point.
   </%doc>
 
   <i style="font-size: ${size}px" class="${gravatar_class} x-icon-size-${size}" data-hovercard-url="${data_hovercard_url}"></i>
 </%def>
 
 <%def name="repo_page_title(repo_instance)">
 <div class="title-content repo-title">
 
     <div class="title-main">
         ## SVN/HG/GIT icons
         %if h.is_hg(repo_instance):
             <i class="icon-hg"></i>
         %endif
         %if h.is_git(repo_instance):
             <i class="icon-git"></i>
         %endif
         %if h.is_svn(repo_instance):
             <i class="icon-svn"></i>
         %endif
 
         ## public/private
         %if repo_instance.private:
             <i class="icon-repo-private"></i>
         %else:
             <i class="icon-repo-public"></i>
         %endif
 
         ## repo name with group name
         ${h.breadcrumb_repo_link(repo_instance)}
 
         ## Context Actions
         <div class="pull-right">
             %if c.rhodecode_user.username != h.DEFAULT_USER:
                 <a href="${h.route_path('atom_feed_home', repo_name=c.rhodecode_db_repo.repo_uid, _query=dict(auth_token=c.rhodecode_user.feed_token))}" title="${_('RSS Feed')}" class="btn btn-sm"><i class="icon-rss-sign"></i>RSS</a>
 
                 <a href="#WatchRepo" onclick="toggleFollowingRepo(this, templateContext.repo_id); return false" title="${_('Watch this Repository and actions on it in your personalized journal')}" class="btn btn-sm ${('watching' if c.repository_is_user_following else '')}">
                     % if c.repository_is_user_following:
                         <i class="icon-eye-off"></i>${_('Unwatch')}
                     % else:
                         <i class="icon-eye"></i>${_('Watch')}
                     % endif
 
                 </a>
             %else:
                 <a href="${h.route_path('atom_feed_home', repo_name=c.rhodecode_db_repo.repo_uid)}" title="${_('RSS Feed')}" class="btn btn-sm"><i class="icon-rss-sign"></i>RSS</a>
             %endif
         </div>
 
     </div>
 
     ## FORKED
     %if repo_instance.fork:
     <p class="discreet">
         <i class="icon-code-fork"></i> ${_('Fork of')}
         ${h.link_to_if(c.has_origin_repo_read_perm,repo_instance.fork.repo_name, h.route_path('repo_summary', repo_name=repo_instance.fork.repo_name))}
     </p>
     %endif
 
     ## IMPORTED FROM REMOTE
     %if repo_instance.clone_uri:
     <p class="discreet">
        <i class="icon-code-fork"></i> ${_('Clone from')}
        <a href="${h.safe_str(h.hide_credentials(repo_instance.clone_uri))}">${h.hide_credentials(repo_instance.clone_uri)}</a>
     </p>
     %endif
 
     ## LOCKING STATUS
      %if repo_instance.locked[0]:
        <p class="locking_locked discreet">
            <i class="icon-repo-lock"></i>
            ${_('Repository locked by %(user)s') % {'user': h.person_by_id(repo_instance.locked[0])}}
        </p>
      %elif repo_instance.enable_locking:
          <p class="locking_unlocked discreet">
              <i class="icon-repo-unlock"></i>
              ${_('Repository not locked. Pull repository to lock it.')}
          </p>
      %endif
 
 </div>
 </%def>
 
 <%def name="repo_menu(active=None)">
     <%
     ## determine if we have "any" option available
     can_lock = h.HasRepoPermissionAny('repository.write','repository.admin')(c.repo_name) and c.rhodecode_db_repo.enable_locking
     has_actions = can_lock
 
     %>
     % if c.rhodecode_db_repo.archived:
     <div class="alert alert-warning text-center">
         <strong>${_('This repository has been archived. It is now read-only.')}</strong>
     </div>
     % endif
 
   <!--- REPO CONTEXT BAR -->
   <div id="context-bar">
     <div class="wrapper">
 
       <div class="title">
           ${self.repo_page_title(c.rhodecode_db_repo)}
       </div>
 
       <ul id="context-pages" class="navigation horizontal-list">
         <li class="${h.is_active('summary', active)}"><a class="menulink" href="${h.route_path('repo_summary_explicit', repo_name=c.repo_name)}"><div class="menulabel">${_('Summary')}</div></a></li>
         <li class="${h.is_active('commits', active)}"><a class="menulink" href="${h.route_path('repo_commits', repo_name=c.repo_name)}"><div class="menulabel">${_('Commits')}</div></a></li>
         <li class="${h.is_active('files', active)}"><a class="menulink" href="${h.repo_files_by_ref_url(c.repo_name, c.rhodecode_db_repo.repo_type, f_path='', ref_name=c.rhodecode_db_repo.landing_ref_name, commit_id='tip', query={'at':c.rhodecode_db_repo.landing_ref_name})}"><div class="menulabel">${_('Files')}</div></a></li>
         <li class="${h.is_active('compare', active)}"><a class="menulink" href="${h.route_path('repo_compare_select',repo_name=c.repo_name)}"><div class="menulabel">${_('Compare')}</div></a></li>
 
         ## TODO: anderson: ideally it would have a function on the scm_instance "enable_pullrequest() and enable_fork()"
         %if c.rhodecode_db_repo.repo_type in ['git','hg']:
           <li class="${h.is_active('showpullrequest', active)}">
             <a class="menulink" href="${h.route_path('pullrequest_show_all', repo_name=c.repo_name)}" title="${h.tooltip(_('Show Pull Requests for %s') % c.repo_name)}">
               <div class="menulabel">
                   ${_('Pull Requests')} <span class="menulink-counter">${c.repository_pull_requests}</span>
               </div>
             </a>
           </li>
         %endif
 
         <li class="${h.is_active('artifacts', active)}">
             <a class="menulink" href="${h.route_path('repo_artifacts_list',repo_name=c.repo_name)}">
                 <div class="menulabel">
                     ${_('Artifacts')}  <span class="menulink-counter">${c.repository_artifacts}</span>
                 </div>
             </a>
         </li>
 
         %if not c.rhodecode_db_repo.archived and h.HasRepoPermissionAll('repository.admin')(c.repo_name):
             <li class="${h.is_active('settings', active)}"><a class="menulink" href="${h.route_path('edit_repo',repo_name=c.repo_name)}"><div class="menulabel">${_('Repository Settings')}</div></a></li>
         %endif
 
         <li class="${h.is_active('options', active)}">
           % if has_actions:
             <a class="menulink dropdown">
               <div class="menulabel">${_('Options')}<div class="show_more"></div></div>
             </a>
             <ul class="submenu">
                 %if can_lock:
                     %if c.rhodecode_db_repo.locked[0]:
                       <li><a class="locking_del" href="${h.route_path('repo_edit_toggle_locking',repo_name=c.repo_name)}">${_('Unlock Repository')}</a></li>
                     %else:
                       <li><a class="locking_add" href="${h.route_path('repo_edit_toggle_locking',repo_name=c.repo_name)}">${_('Lock Repository')}</a></li>
                     %endif
                 %endif
             </ul>
           % endif
         </li>
 
       </ul>
     </div>
     <div class="clear"></div>
   </div>
 
   <!--- REPO END CONTEXT BAR -->
 
 </%def>
 
 <%def name="repo_group_page_title(repo_group_instance)">
 <div class="title-content">
     <div class="title-main">
         ## Repository Group icon
         <i class="icon-repo-group"></i>
 
         ## repo name with group name
         ${h.breadcrumb_repo_group_link(repo_group_instance)}
     </div>
 
     <%namespace name="dt" file="/data_table/_dt_elements.mako"/>
     <div class="repo-group-desc discreet">
     ${dt.repo_group_desc(repo_group_instance.description_safe, repo_group_instance.personal, c.visual.stylify_metatags)}
     </div>
 
 </div>
 </%def>
 
 
 <%def name="repo_group_menu(active=None)">
     <%
     gr_name = c.repo_group.group_name if c.repo_group else None
     # create repositories with write permission on group is set to true
     group_admin = h.HasRepoGroupPermissionAny('group.admin')(gr_name, 'group admin index page')
 
     %>
 
 
   <!--- REPO GROUP CONTEXT BAR -->
   <div id="context-bar">
     <div class="wrapper">
       <div class="title">
           ${self.repo_group_page_title(c.repo_group)}
       </div>
 
       <ul id="context-pages" class="navigation horizontal-list">
         <li class="${h.is_active('home', active)}">
             <a class="menulink" href="${h.route_path('repo_group_home', repo_group_name=c.repo_group.group_name)}"><div class="menulabel">${_('Group Home')}</div></a>
         </li>
         % if c.is_super_admin or group_admin:
             <li class="${h.is_active('settings', active)}">
                 <a class="menulink" href="${h.route_path('edit_repo_group',repo_group_name=c.repo_group.group_name)}" title="${_('You have admin right to this group, and can edit it')}"><div class="menulabel">${_('Group Settings')}</div></a>
             </li>
         % endif
 
       </ul>
     </div>
     <div class="clear"></div>
   </div>
 
   <!--- REPO GROUP CONTEXT BAR -->
 
 </%def>
 
 
 <%def name="usermenu(active=False)">
     <%
     not_anonymous = c.rhodecode_user.username != h.DEFAULT_USER
 
     gr_name = c.repo_group.group_name if (hasattr(c, 'repo_group') and c.repo_group) else None
     # create repositories with write permission on group is set to true
 
     can_fork = c.is_super_admin or h.HasPermissionAny('hg.fork.repository')()
     create_on_write = h.HasPermissionAny('hg.create.write_on_repogroup.true')()
     group_write = h.HasRepoGroupPermissionAny('group.write')(gr_name, 'can write into group index page')
     group_admin = h.HasRepoGroupPermissionAny('group.admin')(gr_name, 'group admin index page')
 
     can_create_repos = c.is_super_admin or c.can_create_repo
     can_create_repo_groups = c.is_super_admin or c.can_create_repo_group
 
     can_create_repos_in_group = c.is_super_admin or group_admin or (group_write and create_on_write)
     can_create_repo_groups_in_group = c.is_super_admin or group_admin
     %>
 
     % if not_anonymous:
     <%
     default_target_group = dict()
     if c.rhodecode_user.personal_repo_group:
         default_target_group = dict(parent_group=c.rhodecode_user.personal_repo_group.group_id)
     %>
 
     ## create action
     <li>
        <a href="#create-actions" onclick="return false;" class="menulink childs">
         <i class="icon-plus-circled"></i>
        </a>
 
        <div class="action-menu submenu">
 
         <ol>
             ## scope of within a repository
             % if hasattr(c, 'rhodecode_db_repo') and c.rhodecode_db_repo:
                 <li class="submenu-title">${_('This Repository')}</li>
                 <li>
                     <a href="${h.route_path('pullrequest_new',repo_name=c.repo_name)}">${_('Create Pull Request')}</a>
                 </li>
                 % if can_fork:
                 <li>
                     <a href="${h.route_path('repo_fork_new',repo_name=c.repo_name,_query=default_target_group)}">${_('Fork this repository')}</a>
                 </li>
                 % endif
             % endif
 
             ## scope of within repository groups
             % if hasattr(c, 'repo_group') and c.repo_group and (can_create_repos_in_group or can_create_repo_groups_in_group):
                 <li class="submenu-title">${_('This Repository Group')}</li>
 
                 % if can_create_repos_in_group:
                     <li>
                     <a href="${h.route_path('repo_new',_query=dict(parent_group=c.repo_group.group_id))}">${_('New Repository')}</a>
                     </li>
                 % endif
 
                 % if can_create_repo_groups_in_group:
                     <li>
                         <a href="${h.route_path('repo_group_new',_query=dict(parent_group=c.repo_group.group_id))}">${_(u'New Repository Group')}</a>
                     </li>
                 % endif
             % endif
 
             ## personal group
             % if c.rhodecode_user.personal_repo_group:
                 <li class="submenu-title">Personal Group</li>
 
                 <li>
                 <a href="${h.route_path('repo_new',_query=dict(parent_group=c.rhodecode_user.personal_repo_group.group_id))}" >${_('New Repository')} </a>
                 </li>
 
                 <li>
                 <a href="${h.route_path('repo_group_new',_query=dict(parent_group=c.rhodecode_user.personal_repo_group.group_id))}">${_('New Repository Group')} </a>
                 </li>
             % endif
 
             ## Global actions
             <li class="submenu-title">RhodeCode</li>
             % if can_create_repos:
                 <li>
                 <a href="${h.route_path('repo_new')}" >${_('New Repository')}</a>
                 </li>
             % endif
 
             % if can_create_repo_groups:
                 <li>
                 <a href="${h.route_path('repo_group_new')}" >${_(u'New Repository Group')}</a>
                 </li>
             % endif
 
             <li>
                 <a href="${h.route_path('gists_new')}">${_(u'New Gist')}</a>
             </li>
 
         </ol>
 
        </div>
     </li>
 
     ## notifications
     <li>
        <a class="${('empty' if c.unread_notifications == 0 else '')}" href="${h.route_path('notifications_show_all')}">
            ${c.unread_notifications}
        </a>
     </li>
    % endif
 
     ## USER MENU
     <li id="quick_login_li" class="${'active' if active else ''}">
         % if c.rhodecode_user.username == h.DEFAULT_USER:
           <a id="quick_login_link" class="menulink childs" href="${h.route_path('login', _query={'came_from': h.current_route_path(request)})}">
             ${gravatar(c.rhodecode_user.email, 20)}
             <span class="user">
                 <span>${_('Sign in')}</span>
             </span>
           </a>
         % else:
           ## logged in user
           <a id="quick_login_link" class="menulink childs">
             ${gravatar(c.rhodecode_user.email, 20)}
             <span class="user">
                 <span class="menu_link_user">${c.rhodecode_user.username}</span>
                 <div class="show_more"></div>
             </span>
           </a>
           ## subnav with menu for logged in user
           <div class="user-menu submenu">
               <div id="quick_login">
                 %if c.rhodecode_user.username != h.DEFAULT_USER:
                     <div class="">
                         <div class="big_gravatar">${gravatar(c.rhodecode_user.email, 48)}</div>
                         <div class="full_name">${c.rhodecode_user.full_name_or_username}</div>
                         <div class="email">${c.rhodecode_user.email}</div>
                     </div>
                     <div class="">
                     <ol class="links">
                       <li>${h.link_to(_(u'My account'),h.route_path('my_account_profile'))}</li>
                       % if c.rhodecode_user.personal_repo_group:
                       <li>${h.link_to(_(u'My personal group'), h.route_path('repo_group_home', repo_group_name=c.rhodecode_user.personal_repo_group.group_name))}</li>
                       % endif
                       <li>${h.link_to(_(u'Pull Requests'), h.route_path('my_account_pullrequests'))}</li>
 
                       % if c.debug_style:
                       <li>
                           <a class="menulink" title="${_('Style')}" href="${h.route_path('debug_style_home')}">
                             <div class="menulabel">${_('[Style]')}</div>
                           </a>
                       </li>
                       % endif
 
                       ## bookmark-items
                       <li class="bookmark-items">
                           ${_('Bookmarks')}
                           <div class="pull-right">
                               <a href="${h.route_path('my_account_bookmarks')}">
 
                                   <i class="icon-cog"></i>
                               </a>
                           </div>
                       </li>
                       % if not c.bookmark_items:
                           <li>
                               <a href="${h.route_path('my_account_bookmarks')}">${_('No Bookmarks yet.')}</a>
                           </li>
                       % endif
                       % for item in c.bookmark_items:
                       <li>
                           % if item.repository:
                               <div>
                                 <a class="bookmark-item" href="${h.route_path('my_account_goto_bookmark', bookmark_id=item.position)}">
                                 <code>${item.position}</code>
                                 % if item.repository.repo_type == 'hg':
                                     <i class="icon-hg" title="${_('Repository')}" style="font-size: 16px"></i>
                                 % elif item.repository.repo_type == 'git':
                                     <i class="icon-git" title="${_('Repository')}" style="font-size: 16px"></i>
                                 % elif item.repository.repo_type == 'svn':
                                     <i class="icon-svn" title="${_('Repository')}" style="font-size: 16px"></i>
                                 % endif
                                 ${(item.title or h.shorter(item.repository.repo_name, 30))}
                               </a>
                               </div>
                           % elif item.repository_group:
                               <div>
                                 <a class="bookmark-item" href="${h.route_path('my_account_goto_bookmark', bookmark_id=item.position)}">
                                 <code>${item.position}</code>
                                 <i class="icon-repo-group" title="${_('Repository group')}" style="font-size: 14px"></i>
                                 ${(item.title or h.shorter(item.repository_group.group_name, 30))}
                               </a>
                               </div>
                           % else:
                               <a class="bookmark-item" href="${h.route_path('my_account_goto_bookmark', bookmark_id=item.position)}">
                                 <code>${item.position}</code>
                                 ${item.title}
                               </a>
                           % endif
                       </li>
                       % endfor
 
                       <li class="logout">
                       ${h.secure_form(h.route_path('logout'), request=request)}
                           ${h.submit('log_out', _(u'Sign Out'),class_="btn btn-primary")}
                       ${h.end_form()}
                       </li>
                     </ol>
                     </div>
                 %endif
               </div>
           </div>
 
         % endif
     </li>
 </%def>
 
 <%def name="menu_items(active=None)">
     <%
         notice_messages, notice_level = c.rhodecode_user.get_notice_messages()
         notice_display = 'none' if len(notice_messages) == 0 else ''
     %>
 
     <ul id="quick" class="main_nav navigation horizontal-list">
        ## notice box for important system messages
        <li style="display: ${notice_display}">
           <a class="notice-box" href="#openNotice" onclick="$('.notice-messages-container').toggle(); return false">
             <div class="menulabel-notice ${notice_level}" >
                 ${len(notice_messages)}
             </div>
           </a>
        </li>
         <div class="notice-messages-container" style="display: none">
         <div class="notice-messages">
             <table class="rctable">
             % for notice in notice_messages:
                 <tr id="notice-message-${notice['msg_id']}" class="notice-message-${notice['level']}">
                     <td style="vertical-align: text-top; width: 20px">
                         <i class="tooltip icon-info notice-color-${notice['level']}" title="${notice['level']}"></i>
                     </td>
                     <td>
                         <span><i class="icon-plus-squared cursor-pointer" onclick="$('#notice-${notice['msg_id']}').toggle()"></i> </span>
                         ${notice['subject']}
 
                         <div id="notice-${notice['msg_id']}" style="display: none">
                             ${h.render(notice['body'], renderer='markdown')}
                         </div>
                     </td>
                     <td style="vertical-align: text-top; width: 35px;">
                         <a class="tooltip" title="${_('dismiss')}" href="#dismiss" onclick="dismissNotice(${notice['msg_id']});return false">
                             <i class="icon-remove icon-filled-red"></i>
                         </a>
                     </td>
                 </tr>
 
             % endfor
             </table>
         </div>
         </div>
         ## Main filter
        <li>
         <div class="menulabel main_filter_box">
             <div class="main_filter_input_box">
                 <ul class="searchItems">
 
                     <li class="searchTag searchTagIcon">
                         <i class="icon-search"></i>
                     </li>
 
                     % if c.template_context['search_context']['repo_id']:
                         <li class="searchTag searchTagFilter searchTagHidable" >
                         ##<a href="${h.route_path('search_repo',repo_name=c.template_context['search_context']['repo_name'])}">
                             <span class="tag">
                                 This repo
                                 <a href="#removeGoToFilter" onclick="removeGoToFilter(); return false"><i class="icon-cancel-circled"></i></a>
                             </span>
                         ##</a>
                         </li>
                     % elif c.template_context['search_context']['repo_group_id']:
                         <li class="searchTag searchTagFilter searchTagHidable">
                         ##<a href="${h.route_path('search_repo_group',repo_group_name=c.template_context['search_context']['repo_group_name'])}">
                             <span class="tag">
                                 This group
                                 <a href="#removeGoToFilter" onclick="removeGoToFilter(); return false"><i class="icon-cancel-circled"></i></a>
                             </span>
                         ##</a>
                         </li>
                     % endif
 
                     <li class="searchTagInput">
                         <input class="main_filter_input" id="main_filter" size="25" type="text" name="main_filter" placeholder="${_('search / go to...')}" value="" />
                     </li>
                     <li class="searchTag searchTagHelp">
                         <a href="#showFilterHelp" onclick="showMainFilterBox(); return false">?</a>
                     </li>
                 </ul>
             </div>
         </div>
 
         <div id="main_filter_help" style="display: none">
 - Use '/' key to quickly access this field.
 
 - Enter a name of repository, or repository group for quick search.
 
 - Prefix query to allow special search:
 
    <strong>user:</strong>admin, to search for usernames, always global
 
    <strong>user_group:</strong>devops, to search for user groups, always global
 
    <strong>pr:</strong>303, to search for pull request number, title, or description, always global
 
    <strong>commit:</strong>efced4, to search for commits, scoped to repositories or groups
 
    <strong>file:</strong>models.py, to search for file paths, scoped to repositories or groups
 
 % if c.template_context['search_context']['repo_id']:
    For advanced full text search visit: <a href="${h.route_path('search_repo',repo_name=c.template_context['search_context']['repo_name'])}">repository search</a>
 % elif c.template_context['search_context']['repo_group_id']:
    For advanced full text search visit: <a href="${h.route_path('search_repo_group',repo_group_name=c.template_context['search_context']['repo_group_name'])}">repository group search</a>
 % else:
    For advanced full text search visit: <a href="${h.route_path('search')}">global search</a>
 % endif
         </div>
        </li>
 
       ## ROOT MENU
         <li class="${h.is_active('home', active)}">
           <a class="menulink" title="${_('Home')}" href="${h.route_path('home')}">
             <div class="menulabel">${_('Home')}</div>
           </a>
         </li>
 
       %if c.rhodecode_user.username != h.DEFAULT_USER:
         <li class="${h.is_active('journal', active)}">
           <a class="menulink" title="${_('Show activity journal')}" href="${h.route_path('journal')}">
             <div class="menulabel">${_('Journal')}</div>
           </a>
         </li>
       %else:
         <li class="${h.is_active('journal', active)}">
           <a class="menulink" title="${_('Show Public activity journal')}" href="${h.route_path('journal_public')}">
             <div class="menulabel">${_('Public journal')}</div>
           </a>
         </li>
       %endif
 
         <li class="${h.is_active('gists', active)}">
           <a class="menulink childs" title="${_('Show Gists')}" href="${h.route_path('gists_show')}">
             <div class="menulabel">${_('Gists')}</div>
           </a>
         </li>
 
         % if c.is_super_admin or c.is_delegated_admin:
         <li class="${h.is_active('admin', active)}">
           <a class="menulink childs" title="${_('Admin settings')}" href="${h.route_path('admin_home')}">
             <div class="menulabel">${_('Admin')} </div>
           </a>
         </li>
         % endif
 
       ## render extra user menu
       ${usermenu(active=(active=='my_account'))}
 
     </ul>
 
     <script type="text/javascript">
         var visualShowPublicIcon = "${c.visual.show_public_icon}" == "True";
 
         var formatRepoResult = function(result, container, query, escapeMarkup) {
             return function(data, escapeMarkup) {
                 if (!data.repo_id){
                   return data.text; // optgroup text Repositories
                 }
 
                 var tmpl = '';
                 var repoType = data['repo_type'];
                 var repoName = data['text'];
 
                 if(data && data.type == 'repo'){
                     if(repoType === 'hg'){
                         tmpl += '<i class="icon-hg"></i> ';
                     }
                     else if(repoType === 'git'){
                         tmpl += '<i class="icon-git"></i> ';
                     }
                     else if(repoType === 'svn'){
                         tmpl += '<i class="icon-svn"></i> ';
                     }
                     if(data['private']){
                         tmpl += '<i class="icon-lock" ></i> ';
                     }
                     else if(visualShowPublicIcon){
                         tmpl += '<i class="icon-unlock-alt"></i> ';
                     }
                 }
                 tmpl += escapeMarkup(repoName);
                 return tmpl;
 
             }(result, escapeMarkup);
         };
 
         var formatRepoGroupResult = function(result, container, query, escapeMarkup) {
             return function(data, escapeMarkup) {
                 if (!data.repo_group_id){
                   return data.text; // optgroup text Repositories
                 }
 
                 var tmpl = '';
                 var repoGroupName = data['text'];
 
                 if(data){
 
                     tmpl += '<i class="icon-repo-group"></i> ';
 
                 }
                 tmpl += escapeMarkup(repoGroupName);
                 return tmpl;
 
             }(result, escapeMarkup);
         };
 
         var escapeRegExChars = function (value) {
             return value.replace(/[\-\[\]\/\{\}\(\)\*\+\?\.\\\^\$\|]/g, "\\$&");
         };
 
         var getRepoIcon = function(repo_type) {
             if (repo_type === 'hg') {
                 return '<i class="icon-hg"></i> ';
             }
             else if (repo_type === 'git') {
                 return '<i class="icon-git"></i> ';
             }
             else if (repo_type === 'svn') {
                 return '<i class="icon-svn"></i> ';
             }
             return ''
         };
 
         var autocompleteMainFilterFormatResult = function (data, value, org_formatter) {
 
             if (value.split(':').length === 2) {
                 value = value.split(':')[1]
             }
 
             var searchType = data['type'];
             var searchSubType = data['subtype'];
             var valueDisplay = data['value_display'];
             var valueIcon = data['value_icon'];
 
             var pattern = '(' + escapeRegExChars(value) + ')';
 
             valueDisplay = Select2.util.escapeMarkup(valueDisplay);
 
             // highlight match
             if (searchType != 'text') {
                 valueDisplay = valueDisplay.replace(new RegExp(pattern, 'gi'), '<strong>$1<\/strong>');
             }
 
             var icon = '';
 
             if (searchType === 'hint') {
                 icon += '<i class="icon-repo-group"></i> ';
             }
             // full text search/hints
             else if (searchType === 'search') {
                 if (valueIcon === undefined) {
                     icon += '<i class="icon-more"></i> ';
                 } else {
                     icon += valueIcon + ' ';
                 }
 
                 if (searchSubType !== undefined && searchSubType == 'repo') {
                     valueDisplay += '<div class="pull-right tag">repository</div>';
                 }
                 else if (searchSubType !== undefined && searchSubType == 'repo_group') {
                     valueDisplay += '<div class="pull-right tag">repo group</div>';
                 }
             }
             // repository
             else if (searchType === 'repo') {
 
                 var repoIcon = getRepoIcon(data['repo_type']);
                 icon += repoIcon;
 
                 if (data['private']) {
                     icon += '<i class="icon-lock" ></i> ';
                 }
                 else if (visualShowPublicIcon) {
                     icon += '<i class="icon-unlock-alt"></i> ';
                 }
             }
             // repository groups
             else if (searchType === 'repo_group') {
                 icon += '<i class="icon-repo-group"></i> ';
             }
             // user group
             else if (searchType === 'user_group') {
                 icon += '<i class="icon-group"></i> ';
             }
             // user
             else if (searchType === 'user') {
                 icon += '<img class="gravatar" src="{0}"/>'.format(data['icon_link']);
             }
             // pull request
             else if (searchType === 'pull_request') {
                 icon += '<i class="icon-merge"></i> ';
             }
             // commit
             else if (searchType === 'commit') {
                 var repo_data = data['repo_data'];
                 var repoIcon = getRepoIcon(repo_data['repository_type']);
                 if (repoIcon) {
                     icon += repoIcon;
                 } else {
                     icon += '<i class="icon-tag"></i>';
                 }
             }
             // file
             else if (searchType === 'file') {
                 var repo_data = data['repo_data'];
                 var repoIcon = getRepoIcon(repo_data['repository_type']);
                 if (repoIcon) {
                     icon += repoIcon;
                 } else {
                     icon += '<i class="icon-tag"></i>';
                 }
             }
             // generic text
             else if (searchType === 'text') {
                 icon = '';
             }
 
             var tmpl = '<div class="ac-container-wrap">{0}{1}</div>';
             return tmpl.format(icon, valueDisplay);
         };
 
         var handleSelect = function(element, suggestion) {
             if (suggestion.type === "hint") {
                 // we skip action
                 $('#main_filter').focus();
             }
             else if (suggestion.type === "text") {
                 // we skip action
                 $('#main_filter').focus();
 
             } else {
               window.location = suggestion['url'];
             }
         };
 
         var autocompleteMainFilterResult = function (suggestion, originalQuery, queryLowerCase) {
             if (queryLowerCase.split(':').length === 2) {
                 queryLowerCase = queryLowerCase.split(':')[1]
             }
             if (suggestion.type === "text") {
                 // special case we don't want to "skip" display for
                 return true
             }
             return suggestion.value_display.toLowerCase().indexOf(queryLowerCase) !== -1;
         };
 
         var cleanContext = {
             repo_view_type: null,
 
             repo_id: null,
             repo_name: "",
 
             repo_group_id: null,
             repo_group_name: null
         };
         var removeGoToFilter = function () {
             $('.searchTagHidable').hide();
             $('#main_filter').autocomplete(
                 'setOptions', {params:{search_context: cleanContext}});
         };
 
         $('#main_filter').autocomplete({
             serviceUrl: pyroutes.url('goto_switcher_data'),
             params: {
                 "search_context": templateContext.search_context
             },
             minChars:2,
             maxHeight:400,
             deferRequestBy: 300, //miliseconds
             tabDisabled: true,
             autoSelectFirst: false,
             containerClass: 'autocomplete-qfilter-suggestions',
             formatResult: autocompleteMainFilterFormatResult,
             lookupFilter: autocompleteMainFilterResult,
             onSelect: function (element, suggestion) {
                 handleSelect(element, suggestion);
                 return false;
             },
             onSearchError: function (element, query, jqXHR, textStatus, errorThrown) {
                 if (jqXHR !== 'abort') {
                     var message = formatErrorMessage(jqXHR, textStatus, errorThrown);
                     SwalNoAnimation.fire({
                         icon: 'error',
                         title: _gettext('Error during search operation'),
                         html: '<span style="white-space: pre-line">{0}</span>'.format(message),
                     }).then(function(result) {
                         window.location.reload();
                     })
                 }
             },
             onSearchStart: function (params) {
                 $('.searchTag.searchTagIcon').html('<i class="icon-spin animate-spin"></i>')
             },
             onSearchComplete: function (query, suggestions) {
                 $('.searchTag.searchTagIcon').html('<i class="icon-search"></i>')
             },
         });
 
         showMainFilterBox = function () {
             $('#main_filter_help').toggle();
         };
 
         $('#main_filter').on('keydown.autocomplete', function (e) {
 
             var BACKSPACE = 8;
             var el = $(e.currentTarget);
             if(e.which === BACKSPACE){
                 var inputVal = el.val();
                 if (inputVal === ""){
                     removeGoToFilter()
                 }
             }
         });
 
         var dismissNotice = function(noticeId) {
 
             var url = pyroutes.url('user_notice_dismiss',
                     {"user_id": templateContext.rhodecode_user.user_id});
 
             var postData = {
                 'csrf_token': CSRF_TOKEN,
                 'notice_id': noticeId,
             };
 
             var success = function(response) {
                 $('#notice-message-' + noticeId).remove();
                 return false;
             };
             var failure = function(data, textStatus, xhr) {
                 alert("error processing request: " + textStatus);
                 return false;
             };
             ajaxPOST(url, postData, success, failure);
         }
 
         var hideLicenseWarning = function () {
             var fingerprint = templateContext.session_attrs.license_fingerprint;
             storeUserSessionAttr('rc_user_session_attr.hide_license_warning', fingerprint);
             $('#notifications').hide();
         }
 
         var hideLicenseError = function () {
             var fingerprint = templateContext.session_attrs.license_fingerprint;
             storeUserSessionAttr('rc_user_session_attr.hide_license_error', fingerprint);
             $('#notifications').hide();
         }
 
     </script>
     <script src="${h.asset('js/rhodecode/base/keyboard-bindings.js', ver=c.rhodecode_version_hash)}"></script>
 </%def>
 
 <div class="modal" id="help_kb" tabindex="-1" role="dialog" aria-labelledby="myModalLabel" aria-hidden="true">
     <div class="modal-dialog">
       <div class="modal-content">
         <div class="modal-header">
           <button type="button" class="close" data-dismiss="modal" aria-hidden="true">&times;</button>
           <h4 class="modal-title" id="myModalLabel">${_('Keyboard shortcuts')}</h4>
         </div>
         <div class="modal-body">
               <div class="block-left">
                 <table class="keyboard-mappings">
                     <tbody>
                   <tr>
                     <th></th>
                     <th>${_('Site-wide shortcuts')}</th>
                   </tr>
                   <%
                      elems = [
                          ('/', 'Use quick search box'),
                          ('g h', 'Goto home page'),
                          ('g g', 'Goto my private gists page'),
                          ('g G', 'Goto my public gists page'),
                          ('g 0-9', 'Goto bookmarked items from 0-9'),
                          ('n r', 'New repository page'),
                          ('n g', 'New gist page'),
                      ]
                   %>
                   %for key, desc in elems:
                   <tr>
                     <td class="keys">
                       <span class="key tag">${key}</span>
                     </td>
                     <td>${desc}</td>
                   </tr>
                 %endfor
                 </tbody>
                   </table>
               </div>
               <div class="block-left">
                 <table class="keyboard-mappings">
                 <tbody>
                   <tr>
                     <th></th>
                     <th>${_('Repositories')}</th>
                   </tr>
                   <%
                      elems = [
                          ('g s', 'Goto summary page'),
                          ('g c', 'Goto changelog page'),
                          ('g f', 'Goto files page'),
                          ('g F', 'Goto files page with file search activated'),
                          ('g p', 'Goto pull requests page'),
                          ('g o', 'Goto repository settings'),
                          ('g O', 'Goto repository access permissions settings'),
                          ('t s', 'Toggle sidebar on some pages'),
                      ]
                   %>
                   %for key, desc in elems:
                   <tr>
                     <td class="keys">
                       <span class="key tag">${key}</span>
                     </td>
                     <td>${desc}</td>
                   </tr>
                 %endfor
                 </tbody>
               </table>
             </div>
         </div>
         <div class="modal-footer">
         </div>
       </div><!-- /.modal-content -->
     </div><!-- /.modal-dialog -->
 </div><!-- /.modal -->
 
 
 <script type="text/javascript">
     (function () {
         "use sctrict";
 
+        // details block auto-hide menu
+        $(document).mouseup(function(e) {
+            var container = $('.details-inline-block');
+            if (!container.is(e.target) && container.has(e.target).length === 0) {
+                $('.details-inline-block[open]').removeAttr('open')
+            }
+        });
+
         var $sideBar = $('.right-sidebar');
         var expanded = $sideBar.hasClass('right-sidebar-expanded');
         var sidebarState = templateContext.session_attrs.sidebarState;
         var sidebarEnabled = $('aside.right-sidebar').get(0);
 
         if (sidebarState === 'expanded') {
             expanded = true
         } else if (sidebarState === 'collapsed') {
             expanded = false
         }
         if (sidebarEnabled) {
             // show sidebar since it's hidden on load
             $('.right-sidebar').show();
 
             // init based on set initial class, or if defined user session attrs
             if (expanded) {
                 window.expandSidebar();
                 window.updateStickyHeader();
 
             } else {
                 window.collapseSidebar();
                 window.updateStickyHeader();
             }
         }
     })()
 
 </script>

rhodecode/templates/base/sidebar.mako

@@ -1,147 +1,151 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 = ''
+            ## Extra precaution to not show drafts in the sidebar for todo/comments
+            if comment_obj.draft:
+                continue
          %>
 
+
          <%
              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')
                   %>
                   ## new comments, since refresh
                   % if existing_ids and comment_obj.comment_id not in existing_ids:
                       <div class="tooltip" style="position: absolute; left: 8px; color: #682668" title="New comment">
                           !
                       </div>
                   % 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