"""

        if userid is None:

            userid = request.authuser.user_id

        user = get_user_or_error(userid)

        ips = db.UserIpMap.query().filter(db.UserIpMap.user == user).all()

        return dict(

            server_ip_addr=request.ip_addr,

            user_ips=ips

        )

    # alias for old

    show_ip = get_ip

    @HasPermissionAnyDecorator('hg.admin')

    def get_server_info(self):

        """

        return server info, including Kallithea version and installed packages

        OUTPUT::

          id : <id_given_in_input>

          result : {

            'py_version': <python version>,

            'platform': <platform type>,

          }

          error :  null

        """

        return db.Setting.get_server_info()

    def get_user(self, userid=None):

        """

        Gets a user by username or user_id, Returns empty result if user is

        not found. If userid param is skipped it is set to id of user who is

        calling this method. This command can be executed only using api_key

        belonging to user with admin rights, or regular users that cannot

        specify different userid than theirs

        :param userid: user to get data for

        :type userid: Optional(str or int)

        OUTPUT::

            id : <id_given_in_input>

            result: None if user does not exist or

                    {

                        "user_id" :     "<user_id>",

                        "username" :    "<username>",

                        "firstname":    "<firstname>",

                        "lastname" :    "<lastname>",

                        "email" :       "<email>",

                        "emails":       "[<list of all emails including additional ones>]",

                        "active" :      "<bool: user active>",

                        "permissions": {

                            "global": ["hg.create.repository",

                                       "repository.read",

                                       "hg.register.manual_activate"],

                            "repositories": {"repo1": "repository.none"},

                         },

                    }

            error:  null

        """

        if not HasPermissionAny('hg.admin')():

            # make sure normal user does not pass someone else userid,

            # he is not allowed to do that

            if userid is not None and userid != request.authuser.user_id:

                raise JSONRPCError(

                    'userid is not the same as your user'

                )

        if userid is None:

            userid = request.authuser.user_id

        user = get_user_or_error(userid)

        data = user.get_api_data()

        data['permissions'] = AuthUser(user_id=user.user_id).permissions

        return data

    @HasPermissionAnyDecorator('hg.admin')

    def get_users(self):

        return [

            user.get_api_data()

            for user in db.User.query()

                .order_by(db.User.username)

                .filter_by(is_default_user=False)

        ]

    @HasPermissionAnyDecorator('hg.admin')

    def create_user(self, username, email, password='',

                    firstname='', lastname='',

                    active=True, admin=False,

                    extern_type=db.User.DEFAULT_AUTH_TYPE,

                    extern_name=''):

        """

        Creates new user. Returns new user object. This command can

        be executed only using api_key belonging to user with admin rights.

        :param username: new username

        :type username: str or int

        :param email: email

        :type email: str

        :param password: password

        :type password: Optional(str)

        :param firstname: firstname

        :param lastname: lastname

        :param active: active

        :type active: Optional(bool)

        :param admin: admin

        :type admin: Optional(bool)

        :param extern_name: name of extern

        :type extern_name: Optional(str)

        :param extern_type: extern_type

        :type extern_type: Optional(str)

        OUTPUT::

            id : <id_given_in_input>

            result: {

                      "msg" : "created new user `<username>`",

                      "user": <user_obj>

                    }

            error:  null

        ERROR OUTPUT::

          id : <id_given_in_input>

          result : null

          error :  {

                extern_name=extern_name

            )

            meta.Session().commit()

            return dict(

                msg='created new user `%s`' % username,

                user=user.get_api_data()

            )

        except Exception:

            log.error(traceback.format_exc())

            raise JSONRPCError('failed to create user `%s`' % (username,))

    @HasPermissionAnyDecorator('hg.admin')

    def update_user(self, userid, username=None,

                    email=None, password=None,

                    firstname=None, lastname=None,

                    active=None, admin=None,

                    extern_type=None, extern_name=None):

        """

        updates given user if such user exists. This command can

        be executed only using api_key belonging to user with admin rights.

        :param userid: userid to update

        :type userid: str or int

        :param username: new username

        :param email: email

        :param password: password

        :type password: Optional(str)

        :param firstname: firstname

        :type firstname: Optional(str)

        :param lastname: lastname

        :type lastname: Optional(str)

        :param active: active

        :type active: Optional(bool)

        :param admin: admin

        :type admin: Optional(bool)

        :param extern_name:

        :type extern_name: Optional(str)

        :param extern_type:

        :type extern_type: Optional(str)

        OUTPUT::

            id : <id_given_in_input>

            result: {

                      "msg" : "updated user ID:<userid> <username>",

                      "user": <user_object>,

                    }

            error:  null

            )

        except Exception:

            log.error(traceback.format_exc())

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

                               % (user.user_id, user.username))

    # permission check inside

    def get_user_group(self, usergroupid):

        """

        Gets an existing user group. This command can be executed only using api_key

        belonging to user with admin rights or user who has at least

        read access to user group.

        :param usergroupid: id of user_group to edit

        :type usergroupid: str or int

        OUTPUT::

            id : <id_given_in_input>

            result : None if group not exist

                     {

                       "users_group_id" : "<id>",

                       "group_name" :     "<groupname>",

                       "active":          "<bool>",

                       "members" :  [<user_obj>,...]

                     }

            error : null

        """

        user_group = get_user_group_or_error(usergroupid)

        if not HasPermissionAny('hg.admin')():

            if not HasUserGroupPermissionLevel('read')(user_group.users_group_name):

                raise JSONRPCError('user group `%s` does not exist' % (usergroupid,))

        data = user_group.get_api_data()

        return data

    # permission check inside

    def get_user_groups(self):

        """

        Lists all existing user groups. This command can be executed only using

        api_key belonging to user with admin rights or user who has at least

        read access to user group.

        OUTPUT::

            id : <id_given_in_input>

            result : [<user_group_obj>,...]

            error : null

        """

        return [

            user_group.get_api_data()

            for user_group in UserGroupList(db.UserGroup.query().all(), perm_level='read')

        ]

    @HasPermissionAnyDecorator('hg.admin', 'hg.usergroup.create.true')

    def create_user_group(self, group_name, description='',

                          owner=None, active=True):

        """

        Creates new user group. This command can be executed only using api_key

        belonging to user with admin rights or an user who has create user group

        permission

        :param group_name: name of new user group

        :type group_name: str

        :param description: group description

        :param owner: owner of group. If not passed apiuser is the owner

        :type owner: Optional(str or int)

        :param active: group is active

        :type active: Optional(bool)

        OUTPUT::

            id : <id_given_in_input>

            result: {

                      "msg": "created new user group `<groupname>`",

                      "user_group": <user_group_object>

                    }

            error:  null

        ERROR OUTPUT::

          id : <id_given_in_input>

          result : null

          error :  {

            "user group `<group name>` already exist"

            or

            "failed to create group `<group name>`"

          }

        store_update(updates, group_name, 'users_group_name')

        store_update(updates, description, 'user_group_description')

        store_update(updates, owner, 'owner')

        store_update(updates, active, 'users_group_active')

        try:

            UserGroupModel().update(user_group, updates)

            meta.Session().commit()

            return dict(

                msg='updated user group ID:%s %s' % (user_group.users_group_id,

                                                     user_group.users_group_name),

                user_group=user_group.get_api_data()

            )

        except Exception:

            log.error(traceback.format_exc())

            raise JSONRPCError('failed to update user group `%s`' % (usergroupid,))

    # permission check inside

    def delete_user_group(self, usergroupid):

        """

        Delete given user group by user group id or name.

        This command can be executed only using api_key

        belonging to user with admin rights or an admin of given user group

        :param usergroupid:

        OUTPUT::

          id : <id_given_in_input>

          result : {

            "msg": "deleted user group ID:<user_group_id> <user_group_name>"

          }

          error :  null

        ERROR OUTPUT::

          id : <id_given_in_input>

          result : null

          error :  {

            "failed to delete user group ID:<user_group_id> <user_group_name>"

            or

            "RepoGroup assigned to <repo_groups_list>"

          }

        """

        user_group = get_user_group_or_error(usergroupid)

        if not HasPermissionAny('hg.admin')():

            if not HasUserGroupPermissionLevel('admin')(user_group.users_group_name):

                raise JSONRPCError('user group `%s` does not exist' % (usergroupid,))

            meta.Session().commit()

            return dict(

                msg='deleted user group ID:%s %s' %

                    (user_group.users_group_id, user_group.users_group_name),

                user_group=None

            )

        except UserGroupsAssignedException as e:

            log.error(traceback.format_exc())

            raise JSONRPCError(str(e))

        except Exception:

            log.error(traceback.format_exc())

            raise JSONRPCError('failed to delete user group ID:%s %s' %

                               (user_group.users_group_id,

                                user_group.users_group_name)

                               )

    # permission check inside

    def add_user_to_user_group(self, usergroupid, userid):

        """

        Adds a user to a user group. If user exists in that group success will be

        `false`. This command can be executed only using api_key

        belonging to user with admin rights  or an admin of given user group

        :param usergroupid:

        :param userid:

        OUTPUT::

          id : <id_given_in_input>

          result : {

              "success": True|False # depends on if member is in group

              "msg": "added member `<username>` to user group `<groupname>` |

                      User is already in that group"

          }

          error :  null

        ERROR OUTPUT::

          id : <id_given_in_input>

          result : null

          error :  {

            "failed to add member to user group `<user_group_name>`"

          }

        """

        user = get_user_or_error(userid)

        user_group = get_user_group_or_error(usergroupid)

        if not HasPermissionAny('hg.admin')():

        :type owner: Optional(str)

        :param repo_type: 'hg' or 'git'

        :type repo_type: Optional(str)

        :param description: repository description

        :type description: Optional(str)

        :param private:

        :type private: bool

        :param clone_uri:

        :type clone_uri: str

        :param landing_rev: <rev_type>:<rev>

        :type landing_rev: str

        :param enable_downloads:

        :type enable_downloads: bool

        :param enable_statistics:

        :type enable_statistics: bool

        :param copy_permissions: Copy permission from group that repository is

            being created.

        :type copy_permissions: bool

        OUTPUT::

            id : <id_given_in_input>

            result: {

                      "msg": "Created new repository `<reponame>`",

                    }

            error:  null

        ERROR OUTPUT::

          id : <id_given_in_input>

          result : null

          error :  {

             'failed to create repository `<repo_name>`

          }

        """

        group_name = None

        repo_name_parts = repo_name.split('/')

        if len(repo_name_parts) > 1:

            group_name = '/'.join(repo_name_parts[:-1])

            repo_group = db.RepoGroup.get_by_group_name(group_name)

            if repo_group is None:

                raise JSONRPCError("repo group `%s` not found" % group_name)

            if not(HasPermissionAny('hg.admin')() or HasRepoGroupPermissionLevel('write')(group_name)):

                raise JSONRPCError("no permission to create repo in %s" % group_name)

        else:

            if not HasPermissionAny('hg.admin', 'hg.create.repository')():

                raise JSONRPCError("no permission to create top level repo")

        :param description:

        :param copy_permissions:

        :param private:

        :param landing_rev:

        INPUT::

            id : <id_for_response>

            api_key : "<api_key>"

            args:     {

                        "repoid" :          "<reponame or repo_id>",

                        "fork_name":        "<forkname>",

                        "owner":            "<username or user_id = Optional(=apiuser)>",

                        "description":      "<description>",

                        "copy_permissions": "<bool>",

                        "private":          "<bool>",

                        "landing_rev":      "<landing_rev>"

                      }

        OUTPUT::

            id : <id_given_in_input>

            result: {

                      "msg": "Created fork of `<reponame>` as `<forkname>`",

                    }

            error:  null

        """

        repo = get_repo_or_error(repoid)

        repo_name = repo.repo_name

        _repo = RepoModel().get_by_repo_name(fork_name)

        if _repo:

            type_ = 'fork' if _repo.fork else 'repo'

            raise JSONRPCError("%s `%s` already exist" % (type_, fork_name))

        group_name = None

        fork_name_parts = fork_name.split('/')

        if len(fork_name_parts) > 1:

            group_name = '/'.join(fork_name_parts[:-1])

            repo_group = db.RepoGroup.get_by_group_name(group_name)

            if repo_group is None:

                raise JSONRPCError("repo group `%s` not found" % group_name)

            if not(HasPermissionAny('hg.admin')() or HasRepoGroupPermissionLevel('write')(group_name)):

                raise JSONRPCError("no permission to create repo in %s" % group_name)

        else:

            if not HasPermissionAny('hg.admin', 'hg.create.repository')():

                raise JSONRPCError("no permission to create top level repo")

            for gist in db.Gist().query()

                .filter_by(is_expired=False)

                .filter(db.Gist.owner_id == user_id)

                .order_by(db.Gist.created_on.desc())

        ]

    def create_gist(self, files, owner=None,

                    gist_type=db.Gist.GIST_PUBLIC, lifetime=-1,

                    description=''):

        """

        Creates new Gist

        :param files: files to be added to gist

            {'filename': {'content':'...', 'lexer': null},

             'filename2': {'content':'...', 'lexer': null}}

        :type files: dict

        :param owner: gist owner, defaults to api method caller

        :type owner: Optional(str or int)

        :param gist_type: type of gist 'public' or 'private'

        :type gist_type: Optional(str)

        :param lifetime: time in minutes of gist lifetime

        :type lifetime: Optional(int)

        :param description: gist description

        OUTPUT::

          id : <id_given_in_input>

          result : {

            "msg": "created new gist",

          }

          error :  null

        ERROR OUTPUT::

          id : <id_given_in_input>

          result : null

          error :  {

            "failed to create gist"

          }

        """

        try:

            if owner is None:

                owner = request.authuser.user_id

            owner = get_user_or_error(owner)

            gist = GistModel().create(description=description,

                                      owner=owner,

                                      ip_addr=request.ip_addr,

                                      gist_mapping=files,

                                      gist_type=gist_type,

                                      lifetime=lifetime)

            meta.Session().commit()

            return dict(

                msg='created new gist',

                gist=gist.get_api_data()

            )

        except Exception:

            log.error(traceback.format_exc())

            raise JSONRPCError('failed to create gist')

    # permission check inside

    def delete_gist(self, gistid):

        """

        Deletes existing gist

        :param gistid: id of gist to delete

        :type gistid: str

        OUTPUT::

          id : <id_given_in_input>

          result : {

            "gist": null

          }

          error :  null

        ERROR OUTPUT::

          id : <id_given_in_input>

          result : null

          error :  {

            "failed to delete gist ID:<gist_id>"

          }

        """

        gist = get_gist_or_error(gistid)

        if not HasPermissionAny('hg.admin')():

            if gist.owner_id != request.authuser.user_id:

                raise JSONRPCError('gist `%s` does not exist' % (gistid,))

        try:

            GistModel().delete(gist)

            meta.Session().commit()

            return dict(

                msg='deleted gist ID:%s' % (gist.gist_access_id,),

                gist=None