elif api_key:

            ApiKeyModel().delete(api_key, request.authuser.user_id)

            Session().commit()

            h.flash(_("API key successfully deleted"), category='success')

        raise HTTPFound(location=url('my_account_api_keys'))

    @IfSshEnabled

    def my_account_ssh_keys(self):

        c.active = 'ssh_keys'

        self.__load_data()

        c.user_ssh_keys = SshKeyModel().get_ssh_keys(request.authuser.user_id)

        return render('admin/my_account/my_account.html')

    @IfSshEnabled

    def my_account_ssh_keys_add(self):

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

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

        try:

            new_ssh_key = SshKeyModel().create(request.authuser.user_id,

                                               description, public_key)

            Session().commit()

            SshKeyModel().write_authorized_keys()

            h.flash(_("SSH key %s successfully added") % new_ssh_key.fingerprint, category='success')

        raise HTTPFound(location=url('my_account_ssh_keys'))

    @IfSshEnabled

    def my_account_ssh_keys_delete(self):

        fingerprint = request.POST.get('del_public_key_fingerprint')

        try:

            SshKeyModel().delete(fingerprint, request.authuser.user_id)

            Session().commit()

            SshKeyModel().write_authorized_keys()

            h.flash(_("SSH key successfully deleted"), category='success')

        raise HTTPFound(location=url('my_account_ssh_keys'))

    @IfSshEnabled

    def edit_ssh_keys(self, id):

        c.user = self._get_user_or_raise_if_default(id)

        c.active = 'ssh_keys'

        c.user_ssh_keys = SshKeyModel().get_ssh_keys(c.user.user_id)

        defaults = c.user.get_dict()

        return htmlfill.render(

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

            defaults=defaults,

            encoding="UTF-8",

            force_defaults=False)

    @IfSshEnabled

    def ssh_keys_add(self, id):

        c.user = self._get_user_or_raise_if_default(id)

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

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

        try:

            new_ssh_key = SshKeyModel().create(c.user.user_id,

                                               description, public_key)

            Session().commit()

            SshKeyModel().write_authorized_keys()

            h.flash(_("SSH key %s successfully added") % new_ssh_key.fingerprint, category='success')

        raise HTTPFound(location=url('edit_user_ssh_keys', id=c.user.user_id))

    @IfSshEnabled

    def ssh_keys_delete(self, id):

        c.user = self._get_user_or_raise_if_default(id)

        fingerprint = request.POST.get('del_public_key_fingerprint')

        try:

            SshKeyModel().delete(fingerprint, c.user.user_id)

            Session().commit()

            SshKeyModel().write_authorized_keys()

            h.flash(_("SSH key successfully deleted"), category='success')

        raise HTTPFound(location=url('edit_user_ssh_keys', id=c.user.user_id))

                gist=None

            )

        except Exception:

            log.error(traceback.format_exc())

            raise JSONRPCError('failed to delete gist ID:%s'

                               % (gist.gist_access_id,))

    # permission check inside

    def get_changesets(self, repoid, start=None, end=None, start_date=None,

                       end_date=None, branch_name=None, reverse=False, with_file_list=False, max_revisions=None):

        repo = get_repo_or_error(repoid)

        if not HasRepoPermissionLevel('read')(repo.repo_name):

            raise JSONRPCError('Access denied to repo %s' % repo.repo_name)

        format = "%Y-%m-%dT%H:%M:%S"

        try:

            return [e.__json__(with_file_list) for e in

                repo.scm_instance.get_changesets(start,

                                                 end,

                                                 datetime.strptime(start_date, format) if start_date else None,

                                                 datetime.strptime(end_date, format) if end_date else None,

                                                 branch_name,

                                                 reverse, max_revisions)]

        except EmptyRepositoryError as e:

    # permission check inside

    def get_changeset(self, repoid, raw_id, with_reviews=Optional(False)):

        repo = get_repo_or_error(repoid)

        if not HasRepoPermissionLevel('read')(repo.repo_name):

            raise JSONRPCError('Access denied to repo %s' % repo.repo_name)

        changeset = repo.get_changeset(raw_id)

        if isinstance(changeset, EmptyChangeset):

            raise JSONRPCError('Changeset %s does not exist' % raw_id)

        info = dict(changeset.as_dict())

        with_reviews = Optional.extract(with_reviews)

        if with_reviews:

            reviews = ChangesetStatusModel().get_statuses(

                                repo.repo_name, raw_id)

            info["reviews"] = reviews

        return info

    # permission check inside

    def get_pullrequest(self, pullrequest_id):

        """

        Get given pull request by id

def to_message(mail, separator="; "):

    """

    Given a MailBase message, this will construct a MIMEPart

    that is canonicalized for use with the Python email API.

    """

    ctype, params = mail.content_encoding['Content-Type']

    if not ctype:

        if mail.parts:

            ctype = 'multipart/mixed'

        else:

            ctype = 'text/plain'

    else:

        if mail.parts:

            assert ctype.startswith(("multipart", "message")), \

                   "Content type should be multipart or message, not %r" % ctype

    # adjust the content type according to what it should be now

    mail.content_encoding['Content-Type'] = (ctype, params)

    try:

        out = MIMEPart(ctype, **params)

        raise EncodingError("Content-Type malformed, not allowed: %r; "

    for k in mail.keys():

        if k in ADDRESS_HEADERS_WHITELIST:

            out[k] = header_to_mime_encoding(

                                         mail[k],

                                         not_email=False,

                                         separator=separator

                                     )

        else:

            out[k] = header_to_mime_encoding(

                                         mail[k],

                                         not_email=True

                                    )

    out.extract_payload(mail)

    # go through the children

    for part in mail.parts:

        out.attach(to_message(part))

    return out

class MIMEPart(MIMEBase):

        :param name: name for new tag

        :param user: full username, i.e.: "Joe Doe <joe.doe@example.com>"

        :param revision: changeset id for which new tag would be created

        :param message: message of the tag's commit

        :param date: date of tag's commit

        :raises TagAlreadyExistError: if tag with same name already exists

        """

        if name in self.tags:

            raise TagAlreadyExistError("Tag %s already exists" % name)

        changeset = self.get_changeset(revision)

        local = kwargs.setdefault('local', False)

        if message is None:

            message = "Added tag %s for changeset %s" % (name,

                changeset.short_id)

        if date is None:

            date = safe_bytes(datetime.datetime.now().strftime('%a, %d %b %Y %H:%M:%S'))

        try:

            mercurial.tags.tag(self._repo, safe_bytes(name), changeset._ctx.node(), safe_bytes(message), local, safe_bytes(user), date)

        except mercurial.error.Abort as e:

        # Reinitialize tags

        self.tags = self._get_tags()

        tag_id = self.tags[name]

        return self.get_changeset(revision=tag_id)

    def remove_tag(self, name, user, message=None, date=None):

        """

        Removes tag with the given ``name``.

        :param name: name of the tag to be removed

        :param user: full username, i.e.: "Joe Doe <joe.doe@example.com>"

        :param message: message of the tag's removal commit

        :param date: date of tag's removal commit

        :raises TagDoesNotExistError: if tag with given name does not exists

        """

        if name not in self.tags:

            raise TagDoesNotExistError("Tag %s does not exist" % name)

        if message is None:

            message = "Removed tag %s" % name

        if date is None:

            date = safe_bytes(datetime.datetime.now().strftime('%a, %d %b %Y %H:%M:%S'))

        local = False

        try:

            mercurial.tags.tag(self._repo, safe_bytes(name), mercurial.commands.nullid, safe_bytes(message), local, safe_bytes(user), date)

            self.tags = self._get_tags()

        except mercurial.error.Abort as e:

    @LazyProperty

    def bookmarks(self):

        """

        Gets bookmarks for this repository

        """

        return self._get_bookmarks()

    def _get_bookmarks(self):

        if self._empty:

            return {}

        return OrderedDict(sorted(

            ((safe_unicode(n), ascii_str(h)) for n, h in self._repo._bookmarks.items()),

            reverse=True,

            key=lambda x: x[0],  # sort by name

        ))

    def _get_all_revisions(self):

        return [ascii_str(self._repo[x].hex()) for x in self._repo.filtered(b'visible').changelog.revs()]

    def get_diff(self, rev1, rev2, path='', ignore_whitespace=False,

                  context=3):

        """

from kallithea.lib.vcs.exceptions import RepositoryError

from kallithea.model.db import User, UserSshKeys

from kallithea.model.meta import Session

log = logging.getLogger(__name__)

class SshKeyModelException(RepositoryError):

    """Exception raised by SshKeyModel methods to report errors"""

class SshKeyModel(object):

    def create(self, user, description, public_key):

        """

        :param user: user or user_id

        :param description: description of SshKey

        :param publickey: public key text

        Will raise SshKeyModelException on errors

        """

        try:

            keytype, pub, comment = ssh.parse_pub_key(public_key)

        except ssh.SshKeyParseError as e:

        if not description.strip():

            description = comment.strip()

        user = User.guess_instance(user)

        new_ssh_key = UserSshKeys()

        new_ssh_key.user_id = user.user_id

        new_ssh_key.description = description

        new_ssh_key.public_key = public_key

        for ssh_key in UserSshKeys.query().filter(UserSshKeys.fingerprint == new_ssh_key.fingerprint).all():

            raise SshKeyModelException(_('SSH key %s is already used by %s') %

                                       (new_ssh_key.fingerprint, ssh_key.user.username))

        Session().add(new_ssh_key)

        return new_ssh_key

    def delete(self, fingerprint, user):

        """

        Deletes ssh key with given fingerprint for the given user.

        Will raise SshKeyModelException on errors

        """

        ssh_key = UserSshKeys.query().filter(UserSshKeys.fingerprint == fingerprint)