Dan Sheridan <djs@adelard.com>

Set locking state on given repository by given user. If userid param is skipped

, then it is set to id of user whos calling this method.

rights or regular user that have admin or write access to repository.

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

show_ip

-------

Shows IP address as seen from RhodeCode server, together with all

defined IP addresses for given user.

This command can be executed only using api_key belonging to user with admin 

rights.

INPUT::

    id : <id_for_response>

    api_key : "<api_key>"

    method :  "show_ip"

    args :    {

                "userid" : "<user_id or username>",

              }

OUTPUT::

    id : <id_given_in_input>

    result : {

                 "ip_addr_server": <ip_from_clien>",

                 "user_ips": [

                                {

                                   "ip_addr": "<ip_with_mask>",

                                   "ip_range": ["<start_ip>", "<end_ip>"],

                                },

                                ...

                             ]

             }

    error :  null

If userid param is skipped it is set to id of user who is calling this method.

rights, or regular users that cannot specify different userid than theirs

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

                "ip_addresses": "<list_of_ip_addresses_for_user>",

                "ip_addresses": "<list_of_ip_addresses_for_user>",

                "username" :  "<username> = Optional(None)",

                "email" :     "<useremail> = Optional(None)",

                "password" :  "<password> = Optional(None)",

                "firstname" : "<firstname> = Optional(None)",

                "lastname" :  "<lastname> = Optional(None)",

                "active" :    "<bool> = Optional(None)",

                "admin" :     "<bool> = Optional(None)",

                "ldap_dn" :   "<ldap_dn> = Optional(None)"

either users_group or user associated to that repository. This command can be 

executed only using api_key belonging to user with admin 

rights or regular user that have at least read access to repository.

                "enable_downloads":  "<bool>",

                "enable_locking":    "<bool>",

                "enable_statistics": "<bool>",                

                "private":           "<bool>",

                "created_on" :       "<date_time_created>",                

                "last_changeset":    {

                                       "author":   "<full_author>",

                                       "date":     "<date_time_of_commit>",

                                       "message":  "<commit_message>",

                                       "raw_id":   "<raw_id>",

                                       "revision": "<numeric_revision>",

                                       "short_id": "<short_id>"

                                     }

Lists all existing repositories. This command can be executed only using 

api_key belonging to user with admin rights or regular user that have 

admin, write or read access to repository.

                "enable_downloads":  "<bool>",

                "enable_locking":    "<bool>",

                "enable_statistics": "<bool>",                   

Creates a repository. If repository name contains "/", all needed repository

groups will be created. For example "foo/bar/baz" will create groups 

"foo", "bar" (with "foo" as parent), and create "baz" repository with 

"bar" as group. This command can be executed only using api_key belonging to user with admin 

rights or regular user that have create repository permission. Regular users

cannot specify owner parameter

                "owner" :            "<onwer_name_or_id = Optional(=apiuser)>",

                "repo_type" :        "<repo_type> = Optional('hg')",

                "enable_downloads":  "<bool> = Optional(False)",

                "enable_locking":    "<bool> = Optional(False)",

                "enable_statistics": "<bool> = Optional(False)",

                "owner":             "<username or user_id>",

                "enable_downloads":  "<bool>",

                "enable_locking":    "<bool>",

                "enable_statistics": "<bool>",                     

fork_repo

---------

Creates a fork of given repo. In case of using celery this will

immidiatelly return success message, while fork is going to be created

asynchronous. This command can be executed only using api_key belonging to

user with admin rights or regular user that have fork permission, and at least

read access to forking repository. Regular users cannot specify owner parameter.

INPUT::

    id : <id_for_response>

    api_key : "<api_key>"

    method :  "fork_repo"

    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>`",

              "success": true

            }

    error:  null

Deletes a repository. This command can be executed only using api_key belonging to user with admin 

rights or regular user that have admin access to repository.

1.5.2 (**2013-01-14**)

----------------------

news

++++

- IP restrictions for users. Each user can get a set of whitelist IP+mask for

  extra protection. Useful for buildbots etc.

- added full last changeset info to lightweight dashboard. lightweight dashboard

  is now fully functional replacement of original dashboard.

- implemented certain API calls for non-admin users.

- enabled all Markdown Extra plugins

- implemented #725 Pull Request View - Show origin repo URL

- show comments from pull requests into associated changesets

fixes

+++++

- update repoinfo script is more failsafe

- fixed #687  Lazy loaded tooltip bug with simultaneous ajax requests

- fixed #691: Notifications for pull requests: move link to top for better

  readability

- fixed #699: fix missing fork docs for API

- fixed #693 Opening changeset from pull request fails

- fixed #710 File view stripping empty lines from beginning and end of file

- fixed issues with getting repos by path on windows, caused GIT hooks to fail

- fixed issues with groups paginator on main dashboard

- improved fetch/pull command for git repos, now pulling all refs

- fixed issue #719 Journal revision ID tooltip AJAX query path is incorrect

  when running in a subdir

- fixed issue #702 API methods without arguments fail when "args":null

- set the status of changesets initially on pull request. Fixes issues #690 and #587

Alternative very detailed installation instructions for Ubuntu Server with

celery, indexer and daemon scripts: https://gist.github.com/4546398

VERSION = (1, 5, 2)

__dbversion__ = 10  # defines current db version for migrations

        m.connect("user_ips", "/users_ips/{id}",

                  action="add_ip", conditions=dict(method=["PUT"]))

        m.connect("user_ips_delete", "/users_ips/{id}",

                  action="delete_ip", conditions=dict(method=["DELETE"]))

            owner = all(un.user.user_id == c.rhodecode_user.user_id

                        for un in no.notifications_to_users)

            owner = all(un.user.user_id == c.rhodecode_user.user_id

                        for un in no.notifications_to_users)

        owner = all(un.user.user_id == c.rhodecode_user.user_id

                    for un in no.notifications_to_users)

from rhodecode.lib.auth import LoginRequired, HasPermissionAllDecorator,\

    AuthUser

from rhodecode.model.db import User, UserIpMap

        if id == 'default':

            c.user = default_user = User.get_by_username('default')

            c.perm_user = AuthUser(user_id=default_user.user_id)

            c.user_ip_map = UserIpMap.query()\

                            .filter(UserIpMap.user == default_user).all()

            _form = DefaultPermissionsForm(

                    [x[0] for x in self.repo_perms_choices],

            c.user = default_user = User.get_by_username('default')

            defaults = {'anonymous': default_user.active}

            c.perm_user = AuthUser(user_id=default_user.user_id)

            c.user_ip_map = UserIpMap.query()\

                            .filter(UserIpMap.user == default_user).all()

                force_defaults=False

        repos_data = RepoModel().get_repos_as_dict(repos_list=c.repos_list,

                                                   admin=True)

        #json used to render the grid

        c.data = json.dumps(repos_data)

            c.repos_list = self.scm_model.get_repos(all_repos=gr_filter)

            repos_data = RepoModel().get_repos_as_dict(repos_list=c.repos_list,

                                                       admin=False)

            #json used to render the grid

            c.data = json.dumps(repos_data)

from rhodecode.model.repo import RepoModel

from rhodecode.lib.utils2 import str2bool, safe_unicode

from rhodecode.lib.compat import json

            _repr = lambda l: ', '.join(map(safe_unicode, l)) or '-'

                      'rescanned added: %s ; removed: %s') %

                    (_repr(added), _repr(removed)),

            recipients = [test_email] if test_email else None

    def _load_my_repos_data(self):

        repos_list = Session().query(Repository)\

                     .filter(Repository.user_id ==

                             self.rhodecode_user.user_id)\

                     .order_by(func.lower(Repository.repo_name)).all()

        repos_data = RepoModel().get_repos_as_dict(repos_list=repos_list,

                                                   admin=True)

        #json used to render the grid

        return json.dumps(repos_data)

        c.ldap_dn = c.user.ldap_dn

        #json used to render the grid

        c.data = self._load_my_repos_data()

        c.user = User.get(self.rhodecode_user.user_id)

        c.ldap_dn = c.user.ldap_dn

            skip_attrs = ['admin', 'active']  # skip attr for my account

            if c.ldap_dn:

                #forbid updating username for ldap accounts

                skip_attrs.append('username')

            UserModel().update(uid, form_result, skip_attrs=skip_attrs)

            #json used to render the grid

            c.data = self._load_my_repos_data()

from rhodecode.model.db import User, UserEmailMap, UserIpMap

        c.perm_user = AuthUser(user_id=id, ip_addr=self.ip_addr)

            c.user_ip_map = UserIpMap.query()\

                            .filter(UserIpMap.user == c.user).all()

        c.perm_user = AuthUser(user_id=id, ip_addr=self.ip_addr)

        c.user_ip_map = UserIpMap.query()\

                        .filter(UserIpMap.user == c.user).all()

    def add_ip(self, id):

        """POST /user_ips:Add an existing item"""

        # url('user_ips', id=ID, method='put')

        ip = request.POST.get('new_ip')

        user_model = UserModel()

        try:

            user_model.add_extra_ip(id, ip)

            Session().commit()

            h.flash(_("Added ip %s to user") % ip, category='success')

        except formencode.Invalid, error:

            msg = error.error_dict['ip']

            h.flash(msg, category='error')

        except Exception:

            log.error(traceback.format_exc())

            h.flash(_('An error occurred during ip saving'),

                    category='error')

        if 'default_user' in request.POST:

            return redirect(url('edit_permission', id='default'))

        return redirect(url('edit_user', id=id))

    def delete_ip(self, id):

        """DELETE /user_ips_delete/id: Delete an existing item"""

        # url('user_ips_delete', id=ID, method='delete')

        user_model = UserModel()

        user_model.delete_extra_ip(id, request.POST.get('del_ip'))

        Session().commit()

        h.flash(_("Removed ip from user"), category='success')

        if 'default_user' in request.POST:

            return redirect(url('edit_permission', id='default'))

        return redirect(url('edit_user', id=id))