plugin = auth_modules.loadplugin(module)

            plugin_name = plugin.name

            formglobals["auth_plugins_shortnames"][module] = plugin_name

            formglobals["plugin_settings"][module] = plugin.plugin_settings()

            for v in formglobals["plugin_settings"][module]:

                fullname = ("auth_" + plugin_name + "_" + v["name"])

                if "default" in v:

                    _defaults[fullname] = v["default"]

                # Current values will be the default on the form, if there are any

                setting = Setting.get_by_name(fullname)

                if setting:

                    _defaults[fullname] = setting.app_settings_value

        _defaults['auth_plugins'] = ','.join(_defaults['auth_plugins'])

        if defaults:

            _defaults.update(defaults)

        formglobals["defaults"] = _defaults

        # set template context variables

        for k, v in formglobals.iteritems():

            setattr(c, k, v)

        log.debug(pprint.pformat(formglobals, indent=4))

        log.debug(formatted_json(defaults))

        return formencode.htmlfill.render(

    @LoginRequired()

    @NotAnonymous()

    @jsonify

    def check_revision(self, gist_id):

        c.gist = Gist.get_or_404(gist_id)

        last_rev = c.gist.scm_instance.get_changeset()

        success = True

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

        ##TODO: maybe move this to model ?

        if revision != last_rev.raw_id:

                      % (revision, last_rev))

            # our gist has newer version than we

            success = False

        return {'success': success}

        c.active = 'advanced'

        if request.POST:

            return redirect(url('repo_edit_advanced'))

        return htmlfill.render(

            render('admin/repos/repo_edit.html'),

            defaults=defaults,

            encoding="UTF-8",

            force_defaults=False)

    @HasRepoPermissionAllDecorator('repository.admin')

    def edit_advanced_journal(self, repo_name):

        """

        :param repo_name:

        """

        cur_token = request.POST.get('auth_token')

        token = get_token()

        if cur_token == token:

            try:

                repo_id = Repository.get_by_repo_name(repo_name).repo_id

                user_id = User.get_default_user().user_id

                self.scm_model.toggle_following_repo(repo_id, user_id)

                h.flash(_('Updated repository visibility in public journal'),

            )

        except Exception:

            log.error(traceback.format_exc())

            raise JSONRPCError(

                'Error occurred during cache invalidation action'

            )

    # permission check inside

    def lock(self, apiuser, repoid, locked=Optional(None),

             userid=Optional(OAttr('apiuser'))):

        """

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

        If locked param is skipped then function shows current lock state of

        given repo. This command can be executed only using api_key belonging

        to user with admin rights or regular user that have admin or write

        access to repository.

        :param apiuser: filled automatically from apikey

        :type apiuser: AuthUser

        :param repoid: repository name or repository id

        :type repoid: str or int

        :param locked: lock state to be set

        :type locked: Optional(bool)

        :param userid: set lock as user

                            % (user.username, repo.repo_name, locked))

                }

                return _d

            except Exception:

                log.error(traceback.format_exc())

                raise JSONRPCError(

                    'Error occurred locking repository `%s`' % repo.repo_name

                )

    def get_locks(self, apiuser, userid=Optional(OAttr('apiuser'))):

        """

        Get all repositories with locks for given userid, if

        who is calling this method, thus returning locks for himself.

        :param apiuser: filled automatically from apikey

        :type apiuser: AuthUser

        :param userid: User to get locks for

        :type userid: Optional(str or int)

        OUTPUT::

          id : <id_given_in_input>

          result : {

            [repo_object, repo_object,...]

          result : {

            'modules': [<module name>,...]

            'py_version': <python version>,

            'platform': <platform type>,

            'kallithea_version': <kallithea version>

          }

          error :  null

        """

        return Setting.get_server_info()

    def get_user(self, apiuser, userid=Optional(OAttr('apiuser'))):

        """

        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 apiuser: filled automatically from apikey

        :type apiuser: AuthUser

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

                        "api_key" :     "<api_key>",

                        "api_keys":     "[<list of all api keys including additional ones>]"

                        "username" :    "<username>",

                        "firstname":    "<firstname>",

                        "lastname" :    "<lastname>",

                        "email" :       "<email>",

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

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

                        "admin" :       "<bool: user is admin>",

                        "extern_name" : "<extern_name>",

                        "extern_type" : "<extern type>

                        "last_login":   "<last_login>",

                        "permissions": {

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

                                       "repository.read",

                                       "hg.register.manual_activate"],

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

                            "repositories_groups": {"Group1": "group.read"}

                         },

                repo_copy_permissions=copy_permissions,

            )

            task = RepoModel().create(form_data=data, cur_user=owner)

            from celery.result import BaseAsyncResult

            task_id = None

            if isinstance(task, BaseAsyncResult):

                task_id = task.task_id

            # no commit, it's done in RepoModel, or async via celery

            return dict(

                msg="Created new repository `%s`" % (repo_name,),

                success=True,  # cannot return the repo data here since fork

                task=task_id

            )

        except Exception:

            log.error(traceback.format_exc())

            raise JSONRPCError(

                'failed to create repository `%s`' % (repo_name,))

    # permission check inside

    def update_repo(self, apiuser, repoid, name=Optional(None),

                    owner=Optional(OAttr('apiuser')),

                    group=Optional(None),

                    description=Optional(''), private=Optional(False),

            )

        except Exception:

            log.error(traceback.format_exc())

            raise JSONRPCError('failed to update repo `%s`' % repoid)

    @HasPermissionAnyDecorator('hg.admin', 'hg.fork.repository')

    def fork_repo(self, apiuser, repoid, fork_name,

                  owner=Optional(OAttr('apiuser')),

                  description=Optional(''), copy_permissions=Optional(False),

                  private=Optional(False), landing_rev=Optional('rev:tip')):

        """

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

        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.

        :param apiuser: filled automatically from apikey

        :type apiuser: AuthUser

        :param repoid: repository name or repository id

        :type repoid: str or int

        :param fork_name:

        :param owner:

        :param description:

        :param copy_permissions:

                fork_parent_id=repo.repo_id,

            )

            task = RepoModel().create_fork(form_data, cur_user=owner)

            # no commit, it's done in RepoModel, or async via celery

            from celery.result import BaseAsyncResult

            task_id = None

            if isinstance(task, BaseAsyncResult):

                task_id = task.task_id

            return dict(

                msg='Created fork of `%s` as `%s`' % (repo.repo_name,

                                                      fork_name),

                success=True,  # cannot return the repo data here since fork

                task=task_id

            )

        except Exception:

            log.error(traceback.format_exc())

            raise JSONRPCError(

                'failed to fork repository `%s` as `%s`' % (repo_name,

                                                            fork_name)

            )

    # permission check inside

    def delete_repo(self, apiuser, repoid, forks=Optional('')):

        """

#

# This program is distributed in the hope that it will be useful,

# but WITHOUT ANY WARRANTY; without even the implied warranty of

# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

# GNU General Public License for more details.

#

# You should have received a copy of the GNU General Public License

# along with this program.  If not, see <http://www.gnu.org/licenses/>.

"""

kallithea.controllers.changeset

~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

revisions

This file was forked by the Kallithea project in July 2014.

Original author and date, and relevant copyright and licensing information is below:

:created_on: Apr 25, 2010

:author: marcink

:copyright: (c) 2013 RhodeCode GmbH, and others.

:license: GPLv3, see LICENSE.md for more details.

"""

import logging

import traceback

                shutil.move(archive, cached_archive_path)

                archive = cached_archive_path

        def get_chunked_archive(archive):

            stream = open(archive, 'rb')

            while True:

                data = stream.read(16 * 1024)

                if not data:

                    stream.close()

                    if fd:  # fd means we used temporary file

                        os.close(fd)

                    if not archive_cache_enabled:

                        os.remove(archive)

                    break

                yield data

        # store download action

        action_logger(user=c.authuser,

                      action='user_downloaded_archive:%s' % (archive_name),

                      repo=repo_name, ipaddr=self.ip_addr, commit=True)

        response.content_disposition = str('attachment; filename=%s' % (archive_name))

        response.content_type = str(content_type)

        return get_chunked_archive(archive)

    @LoginRequired()

        c.update_msg_other = ""

        if org_scm_instance.alias == 'hg' and c.a_ref_name != 'ancestor':

            if c.cs_ref_type != 'branch':

                c.cs_branch_name = org_scm_instance.get_changeset(c.cs_ref_name).branch # use ref_type ?

            c.a_branch_name = c.a_ref_name

            if c.a_ref_type != 'branch':

                try:

                    c.a_branch_name = other_scm_instance.get_changeset(c.a_ref_name).branch # use ref_type ?

                except EmptyRepositoryError:

                    c.a_branch_name = 'null' # not a branch name ... but close enough

            # candidates: descendants of old head that are on the right branch

            #             and not are the old head itself ...

            if other_scm_instance._repo.revs('present(%s)::&%s', c.cs_ranges[-1].raw_id, c.a_branch_name):

                c.update_msg = _('This pull request has already been merged to %s.') % c.a_branch_name

            elif c.pull_request.is_closed():

                c.update_msg = _('This pull request has been closed and can not be updated.')

            else: # look for descendants of PR head on source branch in org repo

                avail_revs = org_scm_instance._repo.revs('%s:: & branch(%s)',

                                                         revs[0], c.cs_branch_name)

                if len(avail_revs) > 1: # more than just revs[0]

                    # also show changesets that not are descendants but would be merged in

                    targethead = other_scm_instance.get_changeset(c.a_branch_name).raw_id

                    show = set(org_scm_instance._repo.revs('::%ld & !::%s & !::%s',

                                                           avail_revs, revs[0], targethead))