text = text or (_('Status change -> %s')

                            % ChangesetStatus.get_status_lbl(status))

            text=text,

            repo=c.rhodecode_db_repo.repo_id,

            user=c.rhodecode_user.user_id,

        if not request.environ.get('HTTP_X_PARTIAL_XHR'):

            return redirect(h.url('changeset_home', repo_name=repo_name,

                                  revision=revision))

        data = {

           'target_id': h.safeid(h.safe_unicode(request.POST.get('f_path'))),

        }

        if comm:

            data.update(comm.get_dict())

            data.update({'rendered_text':

                         render('changeset/changeset_comment_block.html')})

        status = request.POST.get('changeset_status')

        change_status = request.POST.get('change_changeset_status')

        text = request.POST.get('text')

        allowed_to_change_status = self._get_is_allowed_change_status(pull_request)

        if status and change_status and allowed_to_change_status:

                            % ChangesetStatus.get_status_lbl(status))

        comm = ChangesetCommentsModel().create(

            text=text,

            repo=c.rhodecode_db_repo.repo_id,

            f_path=request.POST.get('f_path'),

            line_no=request.POST.get('line'),

            status_change=(ChangesetStatus.get_status_lbl(status)

        )

        action_logger(self.rhodecode_user,

                    pull_request=pull_request_id

                )

                if status in ['rejected', 'approved']:

                    PullRequestModel().close_pull_request(pull_request_id)

                    action_logger(self.rhodecode_user,

from rhodecode.model.db import ChangesetComment, User, Repository, \

    Notification, PullRequest

from rhodecode.model.notification import NotificationModel

log = logging.getLogger(__name__)

                user_objects.append(user_obj)

        return user_objects

    def create(self, text, repo, user, revision=None, pull_request=None,

        """

        Creates new comment for changeset or pull request.

        IF status_change is not none this comment is associated with a

        :param f_path:

        :param line_no:

        :param status_change:

        :param send_email:

        """

        if not text:

            return

        repo = self._get_repo(repo)

        comment.line_no = line_no

        if revision:

            comment.revision = revision

        elif pull_request:

            pull_request = self.__get_pull_request(pull_request)

        else:

            raise Exception('Please specify revision or pull_request_id')

        if send_email:

            # create notification objects, and emails

            NotificationModel().create(

                created_by=user, subject=subj, body=body,

                recipients=recipients, type_=notification_type,

            )

            mention_recipients = set(self._extract_mentions(body))\

        :param comment_id:

        """

        comment = self.__get_changeset_comment(comment)

        return comment

        Get's main comments based on revision or pull_request_id

        :param repo_id:

        :param revision:

        :param pull_request:

        """

        q = ChangesetComment.query()\

        return q.all()

    def get_inline_comments(self, repo_id, revision=None, pull_request=None):

            .filter(ChangesetComment.repo_id == repo_id)\

            .filter(ChangesetComment.line_no != None)\

            .filter(ChangesetComment.f_path != None)\

from rhodecode.lib import helpers as h

from rhodecode.model import BaseModel

from rhodecode.model.db import Notification, User, UserNotification

log = logging.getLogger(__name__)

    def create(self, created_by, subject, body, recipients=None,

               type_=Notification.TYPE_MESSAGE, with_email=True,

        """

        Creates notification of given type

        :param type_: type of notification

        :param with_email: send email with this notification

        :param email_kwargs: additional dict to pass as args to email template

        """

        from rhodecode.lib.celerylib import tasks, run_task

        # send email with notification to all other participants

        for rec in rec_objs:

            type_ = type_

            email_body = body

            ## this is passed into template

                        .filter(UserNotification.notification

                                == notification)\

                        .one()

                return True

        except Exception:

            log.error(traceback.format_exc())

        Get mentions for given user, filter them if filter dict is given

        :param user:

        :param filter:

        """

        user = self._get_user(user)

                                == notification)\

                        .one()

                obj.read = True

                return True

        except Exception:

            log.error(traceback.format_exc())

        # update on joined tables :(

        for obj in q.all():

            obj.read = True

    def get_unread_cnt_for_user(self, user):

        user = self._get_user(user)

        #alias

        _n = notification

        _map = {

            _n.TYPE_MESSAGE: _('sent message at %(when)s'),

            _n.TYPE_MENTION: _('mentioned you at %(when)s'),

            _n.TYPE_REGISTRATION: _('registered in RhodeCode at %(when)s'),

        new.title = title

        new.description = description

        new.author = created_by_user

        Session().flush()

        #members

        for member in set(reviewers):

            _usr = self._get_user(member)

            reviewer = PullRequestReviewers(_usr, new)

        #reset state to under-review

        ChangesetStatusModel().set_status(

            user=created_by_user,

            pull_request=new

        )

        #notification to reviewers

        notif = NotificationModel()

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

                                 qualified=True,),

            'pr_url': pr_url,

        }

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

        for uid in to_add:

            _usr = self._get_user(uid)

            reviewer = PullRequestReviewers(_usr, pull_request)

        for uid in to_remove:

            reviewer = PullRequestReviewers.query()\

                            PullRequestReviewers.pull_request==pull_request)\

                    .scalar()

            if reviewer:

    def delete(self, pull_request):

        pull_request = self.__get_pull_request(pull_request)

        pull_request = self.__get_pull_request(pull_request)

        pull_request.status = PullRequest.STATUS_CLOSED

        pull_request.updated_on = datetime.datetime.now()

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

        """

## -*- coding: utf-8 -*-

<%inherit file="main.html"/>

${body}

</p>

<div>${_('revisions for reviewing')}</div>

%endfor

## -*- coding: utf-8 -*-

<%inherit file="main.html"/>

<div>${_('View this comment here')}: ${pr_comment_url}</div>

%if status_change:

%endif

</p>

                <span style="font-size: 20px">

                ${h.select('org_repo','',c.org_repos,class_='refs')}:${h.select('org_ref',c.default_org_ref,c.org_refs,class_='refs')}

                </span>

            </div>

            <div style="clear:both;padding-top: 10px"></div>

        </div>

                <span style="font-size: 20px">

                ${h.select('other_repo',c.default_other_repo,c.other_repos,class_='refs')}:${h.select('other_ref',c.default_other_ref,c.default_other_refs,class_='refs')}

                </span>

            </div>

            <div style="clear:both;padding-top: 10px"></div>

        </div>