if not st or st.status in (ChangesetStatus.STATUS_NOT_REVIEWED,

                                       ChangesetStatus.STATUS_UNDER_REVIEW):

                st = None

                pull_request_pending_reviewers.append(r.user)

            pull_request_reviewers.append((r.user, st))

        # calculate result

        result = ChangesetStatus.STATUS_UNDER_REVIEW

        if approved_votes and approved_votes == len(pull_request.reviewers):

            result = ChangesetStatus.STATUS_APPROVED

        return (pull_request_reviewers,

                pull_request_pending_reviewers,

                result)

    def get_statuses(self, repo, revision=None, pull_request=None,

                     with_revisions=False):

        q = self._get_status_query(repo, revision, pull_request,

                                   with_revisions)

        return q.all()

    def get_status(self, repo, revision=None, pull_request=None, as_str=True):

        """

        Returns latest status of changeset for given revision or for given

        pull request. Statuses are versioned inside a table itself and

        version == 0 is always the current one

        :param repo:

        :param revision: 40char hash or None

        :param pull_request: pull_request reference

        :param as_str: return status as string not object

        """

        q = self._get_status_query(repo, revision, pull_request)

        # need to use first here since there can be multiple statuses

        # returned from pull_request

        status = q.first()

        if as_str:

            return str(status.status) if status else ChangesetStatus.DEFAULT

        return status

    def set_status(self, repo, status, user, comment, revision=None,

                   pull_request=None, dont_allow_on_closed_pull_request=False):

        """

        Creates new status for changeset or updates the old ones bumping their

        version, leaving the current status at

        :param repo:

        :param status:

        :param user:

        :param comment:

        :param dont_allow_on_closed_pull_request: don't allow a status change

            if last status was for pull request and it's closed. We shouldn't

            mess around this manually

        """

        repo = self._get_repo(repo)

        q = ChangesetStatus.query()

            q = q.filter(ChangesetStatus.repo == repo)

            q = q.filter(ChangesetStatus.revision == revision)

            pull_request = self.__get_pull_request(pull_request)

            q = q.filter(ChangesetStatus.revision.in_(pull_request.revisions))

        cur_statuses = q.all()

        #if statuses exists and last is associated with a closed pull request

        # we need to check if we can allow this status change

        if (dont_allow_on_closed_pull_request and cur_statuses

            and getattr(cur_statuses[0].pull_request, 'status', '')

                == PullRequest.STATUS_CLOSED):

            raise StatusChangeOnClosedPullRequestError(

                'Changing status on closed pull request is not allowed'

            )

        #update all current statuses with older version

            for st in cur_statuses:

                st.version += 1

                self.sa.add(st)

            new_status = ChangesetStatus()

            new_status.version = 0 # default

            new_status.author = self._get_user(user)

            new_status.repo = self._get_repo(repo)

            new_status.status = status

            new_status.comment = comment

            new_status.pull_request = pull_request

                new_statuses.append(new_status)

                self.sa.add(new_status)

            return new_statuses

        #pull request

        elif pull_request:

            notification_type = Notification.TYPE_PULL_REQUEST_COMMENT

            desc = comment.pull_request.title

            _url = h.url('pullrequest_show',

                repo_name=pull_request.other_repo.repo_name,

                pull_request_id=pull_request.pull_request_id,

                anchor='comment-%s' % comment.comment_id,

                qualified=True,

            )

            subj = safe_unicode(

                h.link_to('Re pull request #%(pr_id)s: %(desc)s %(line)s' % \

                          {'desc': desc,

                           'pr_id': comment.pull_request.pull_request_id,

                           'line': line},

                          _url)

            )

            email_subject = '%s commented on pull request #%s' % \

                    (user.username, comment.pull_request.pull_request_id)

            # get the current participants of this pull request

            recipients = ChangesetComment.get_users(pull_request_id=

                                                pull_request.pull_request_id)

            # add pull request author

            recipients += [pull_request.author]

            # add the reviewers to notification

            recipients += [x.user for x in pull_request.reviewers]

            #set some variables for email notification

            email_kwargs = {

                'pr_title': pull_request.title,

                'pr_id': pull_request.pull_request_id,

                'status_change': status_change,

                'closing_pr': closing_pr,

                'pr_comment_url': _url,

                'pr_comment_user': h.person(user.email),

                'pr_target_repo': h.url('summary_home',

                                   repo_name=pull_request.other_repo.repo_name,

                                   qualified=True)

            }

        return subj, body, recipients, notification_type, email_kwargs, email_subject

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

               f_path=None, line_no=None, status_change=None, closing_pr=False,

               send_email=True):

        """

        Creates new comment for changeset or pull request.

        status change of changeset or changesets associated with pull request

        :param text:

        :param repo:

        :param user:

        :param revision:

        :param f_path:

        :param line_no:

        """

        if not text:

            log.warning('Missing text for comment, skipping...')

            return

        repo = self._get_repo(repo)

        user = self._get_user(user)

        comment = ChangesetComment()

        comment.repo = repo

        comment.author = user

        comment.text = text

        comment.f_path = f_path

        comment.line_no = line_no

        if revision:

            comment.revision = revision

        elif pull_request:

            pull_request = self.__get_pull_request(pull_request)

            comment.pull_request = pull_request

        else:

            raise Exception('Please specify revision or pull_request_id')

        Session().add(comment)

        Session().flush()

        if send_email:

            (subj, body, recipients, notification_type,

             email_kwargs, email_subject) = self._get_notification_data(

                                repo, comment, user,

                                comment_text=text,

                                line_no=line_no,

                                revision=revision,

                                pull_request=pull_request,

                                status_change=status_change,

                                closing_pr=closing_pr)

            # create notification objects, and emails

            NotificationModel().create(

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

                recipients=recipients, type_=notification_type,

                email_kwargs=email_kwargs, email_subject=email_subject

            )

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

                                    .difference(recipients)

            if mention_recipients:

                email_kwargs.update({'pr_mention': True})

                subj = _('[Mention]') + ' ' + subj

                NotificationModel().create(