upstream/kallithea Commit - r8721:6f9dec22

api docs: drop extra newlines in docstrings

Mads Kiilerich -

r8721:6f9dec22 stable

parent child

docs/api/api.rst

0 0 -2

                                              ...
                                           ]
                           }
                  error :  null
              get_user
                              "copy_permissions": "<bool>",
                              "private":          "<bool>",
                              "landing_rev":      "<landing_rev>"
                            }
              OUTPUT::

kallithea/controllers/api/api.py

0 0 -54

                        error :  {
                          "Unable to pull changes from `<reponame>`"
                        }
                      """
                      repo = get_repo_or_error(repoid)
                      try:
                        error :  {
                          'Error occurred during rescan repositories action'
                        }
                      """
                      try:
                          rm_obsolete = remove_obsolete
                          added, removed = repo2db_mapper(ScmModel().repo_scan(),
                        error :  {
                          'Error occurred during cache invalidation action'
                        }
                      """
                      repo = get_repo_or_error(repoid)
                      if not HasPermissionAny('hg.admin')():
                      """
                      return server info, including Kallithea version and installed packages
                      OUTPUT::
                        id : <id_given_in_input>
                                          "user_groups": { "usrgrp1": "usergroup.admin" }
                                       },
                                  }
                          error:  null
                      """
                      if not HasPermissionAny('hg.admin')():
                          # make sure normal user does not pass someone else userid,
                      Lists all existing users. This command can be executed only using api_key
                      belonging to user with admin rights.
                      OUTPUT::
                          id : <id_given_in_input>
                          result: [<user_object>, ...]
                          error:  null
                      """
                      return [
                          user.get_api_data()
                          for user in db.User.query()
                      :param extern_type: extern_type
                      :type extern_type: Optional(str)
                      OUTPUT::
                          id : <id_given_in_input>
                          or
                          "failed to create user `<username>`"
                        }
                      """
                      if db.User.get_by_username(username):
                          raise JSONRPCError("user `%s` already exist" % (username,))
                      :param extern_type:
                      :type extern_type: Optional(str)
                      OUTPUT::
                          id : <id_given_in_input>
                        error :  {
                          "failed to update user `<username>`"
                        }
                      """
                      user = get_user_or_error(userid)
                      # only non optional arguments will be stored in updates
                        error :  {
                          "failed to delete user ID:<userid> <username>"
                        }
                      """
                      user = get_user_or_error(userid)
                                     "members" :  [<user_obj>,...]
                                   }
                          error : null
                      """
                      user_group = get_user_group_or_error(usergroupid)
                      if not HasPermissionAny('hg.admin')():
                      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')
                          or
                          "failed to create group `<group name>`"
                        }
                      """
                      if UserGroupModel().get_by_name(group_name):
                          raise JSONRPCError("user group `%s` already exist" % (group_name,))
                        error :  {
                          "failed to update user group `<user group name>`"
                        }
                      """
                      user_group = get_user_group_or_error(usergroupid)
                      if not HasPermissionAny('hg.admin')():
                          or
                          "RepoGroup assigned to <repo_groups_list>"
                        }
                      """
                      user_group = get_user_group_or_error(usergroupid)
                      if not HasPermissionAny('hg.admin')():
                            "success": True|False # depends on if member is in group
                            "msg": "added member `<username>` to a user group `<groupname>` |
                                    User is already in that group"
                        }
                        error :  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)
                      :param usergroupid:
                      :param userid:
                      OUTPUT::
                          id : <id_given_in_input>
                                            User wasn't in group"
                                  }
                          error:  null
                      """
                      user = get_user_or_error(userid)
                      user_group = get_user_group_or_error(usergroupid)
                                       },
                        }
                        error :  null
                      """
                      repo = get_repo_or_error(repoid)
                      api_key belonging to user with admin rights or regular user that have
                      admin, write or read access to repository.
                      OUTPUT::
                          id : <id_given_in_input>
                      :param ret_type: return type 'all|files|dirs' nodes
                      :type ret_type: Optional(str)
                      OUTPUT::
                          id : <id_given_in_input>
                        error :  {
                           'failed to create repository `<repo_name>`
                        }
                      """
                      group_name = None
                      repo_name_parts = repo_name.split('/')
                                  clone_uri=None, landing_rev=None,
                                  enable_statistics=None,
                                  enable_downloads=None):
                      """
                      Updates repo
                                    "success": true
                                  }
                          error:  null
                      """
                      repo = get_repo_or_error(repoid)
                      repo_name = repo.repo_name
                                    "success": true
                                  }
                          error:  null
                      """
                      repo = get_repo_or_error(repoid)
                                    "success": true
                                  }
                          error:  null
                      """
                      repo = get_repo_or_error(repoid)
                      user = get_user_or_error(userid)
                      try:
                        result : {
                          "msg" : "Granted perm: `<perm>` for group: `<usersgroupname>` in repo: `<reponame>`",
                          "success": true
                        }
                        error :  null
                        error :  {
                          "failed to edit permission for user group: `<usergroup>` in repo `<repo>`'
                        }
                      """
                      repo = get_repo_or_error(repoid)
                      perm = get_perm_or_error(perm)
                  def get_repo_groups(self):
                      """
                      Returns all repository groups
                      """
                      return [
                          repo_group.get_api_data()
                        error :  {
                          failed to create repo group `<repogroupid>`
                        }
                      """
                      if db.RepoGroup.get_by_group_name(group_name):
                          raise JSONRPCError("repo group `%s` already exist" % (group_name,))
                  @HasPermissionAnyDecorator('hg.admin')
                  def delete_repo_group(self, repogroupid):
                      """
                      :param repogroupid: name or id of repository group
                      :type repogroupid: str or int
                        error :  {
                          "failed to delete repo group ID:<repogroupid> <repogroupname>"
                        }
                      """
                      repo_group = get_repo_group_or_error(repogroupid)
                        error :  {
                          "failed to edit permission for user: `<userid>` in repo group: `<repo_group_name>`"
                        }
                      """
                      repo_group = get_repo_group_or_error(repogroupid)
                      if not HasPermissionAny('hg.admin')():
                        error :  {
                          "failed to edit permission for user: `<userid>` in repo group: `<repo_group_name>`"
                        }
                      """
                      repo_group = get_repo_group_or_error(repogroupid)
                      if not HasPermissionAny('hg.admin')():
                        result : {
                          "msg" : "Granted perm: `<perm>` (recursive:<apply_to_children>) for user group: `<usersgroupname>` in repo group: `<repo_group_name>`",
                          "success": true
                        }
                        error :  null
                        error :  {
                          "failed to edit permission for user group: `<usergroup>` in repo group: `<repo_group_name>`"
                        }
                      """
                      repo_group = get_repo_group_or_error(repogroupid)
                      perm = get_perm_or_error(perm, prefix='group.')
                        error :  {
                          "failed to edit permission for user group: `<usergroup>` in repo group: `<repo_group_name>`"
                        }
                      """
                      repo_group = get_repo_group_or_error(repogroupid)
                      user_group = get_user_group_or_error(usergroupid)
                  def create_gist(self, files, owner=None,
                                  gist_type=db.Gist.GIST_PUBLIC, lifetime=-1,
                                  description=''):
                      """
                      Creates new Gist
                        error :  {
                          "failed to create gist"
                        }
                      """
                      try:
                          if owner is None:
                        error :  {
                          "failed to delete gist ID:<gist_id>"
                        }
                      """
                      gist = get_gist_or_error(gistid)
                      if not HasPermissionAny('hg.admin')():

General Comments 0

Write
Preview

You need to be logged in to leave comments. Login now

No TODOs yet

	Site-wide shortcuts
/	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

	Repositories
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