"""

        from rhodecode.lib.auth import AuthUser

        user = self._get_user(user)

        repos = AuthUser(user_id=user.user_id).permissions['repositories']

        access_check = lambda r: r[1] in ['repository.read',

                                          'repository.write',

                                          'repository.admin']

        repos = [x[0] for x in filter(access_check, repos.items())]

        return Repository.query().filter(Repository.repo_name.in_(repos))

    def get_users_js(self):

        users = self.sa.query(User).filter(User.active == True).all()

        return json.dumps([

            {

             'id': u.user_id,

             'fname': u.name,

             'lname': u.lastname,

             'nname': u.username,

             'gravatar_lnk': h.gravatar_url(u.email, 14)

            } for u in users]

        )

    def get_users_groups_js(self):

        users_groups = self.sa.query(UserGroup)\

            .filter(UserGroup.users_group_active == True).all()

        users_groups = UserGroupList(users_groups, perm_set=['usergroup.read',

                                                             'usergroup.write',

                                                             'usergroup.admin'])

        return json.dumps([

            {

             'id': gr.users_group_id,

             'grname': gr.users_group_name,

             'grmembers': len(gr.members),

            } for gr in users_groups]

        )

    @classmethod

    def _render_datatable(cls, tmpl, *args, **kwargs):

        import rhodecode

        from pylons import tmpl_context as c

        from pylons.i18n.translation import _

        _tmpl_lookup = rhodecode.CONFIG['pylons.app_globals'].mako_lookup

        template = _tmpl_lookup.get_template('data_table/_dt_elements.html')

        tmpl = template.get_def(tmpl)

        kwargs.update(dict(_=_, h=h, c=c))

        return tmpl.render(*args, **kwargs)

    @classmethod

    def update_repoinfo(cls, repositories=None):

        if not repositories:

            repositories = Repository.getAll()

        for repo in repositories:

            repo.update_changeset_cache()

    def get_repos_as_dict(self, repos_list=None, admin=False, perm_check=True,

                          super_user_actions=False):

        _render = self._render_datatable

        from pylons import tmpl_context as c

        def quick_menu(repo_name):

            return _render('quick_menu', repo_name)

        def repo_lnk(name, rtype, private, fork_of):

            return _render('repo_name', name, rtype, private, fork_of,

                           short_name=not admin, admin=False)

        def last_change(last_change):

            return _render("last_change", last_change)

        def rss_lnk(repo_name):

            return _render("rss", repo_name)

        def atom_lnk(repo_name):

            return _render("atom", repo_name)

        def last_rev(repo_name, cs_cache):

            return _render('revision', repo_name, cs_cache.get('revision'),

                           cs_cache.get('raw_id'), cs_cache.get('author'),

                           cs_cache.get('message'))

        def desc(desc):

            if c.visual.stylify_metatags:

                return h.urlify_text(h.desc_stylize(h.truncate(desc, 60)))

            else:

                return h.urlify_text(h.truncate(desc, 60))

        def repo_actions(repo_name):

            return _render('repo_actions', repo_name, super_user_actions)

        def owner_actions(user_id, username):

            return _render('user_name', user_id, username)

        repos_data = []

        for repo in repos_list:

            if perm_check:

                # check permission at this level

                if not HasRepoPermissionAny(

                    'repository.read', 'repository.write', 'repository.admin'

                )(repo.repo_name, 'get_repos_as_dict check'):

                    continue

            cs_cache = repo.changeset_cache

            row = {

                "menu": quick_menu(repo.repo_name),

                "raw_name": repo.repo_name.lower(),

                "name": repo_lnk(repo.repo_name, repo.repo_type,

                                 repo.private, repo.fork),

                "last_change": last_change(repo.last_db_change),

                "last_changeset": last_rev(repo.repo_name, cs_cache),

                "raw_tip": cs_cache.get('revision'),

                "desc": desc(repo.description),

                "owner": h.person(repo.user.username),

                "rss": rss_lnk(repo.repo_name),

                "atom": atom_lnk(repo.repo_name),

            }

            if admin:

                row.update({

                    "action": repo_actions(repo.repo_name),

                    "owner": owner_actions(repo.user.user_id,

                                           h.person(repo.user.username))

                })

            repos_data.append(row)

        return {

            "totalRecords": len(repos_list),

            "startIndex": 0,

            "sort": "name",

            "dir": "asc",

            "records": repos_data

        }

    def _get_defaults(self, repo_name):

        """

        Get's information about repository, and returns a dict for

        usage in forms

        :param repo_name:

        """

        repo_info = Repository.get_by_repo_name(repo_name)

        if repo_info is None:

            return None

        defaults = repo_info.get_dict()

        group, repo_name, repo_name_full = repo_info.groups_and_repo

        defaults['repo_name'] = repo_name

        defaults['repo_group'] = getattr(group[-1] if group else None,

                                         'group_id', None)

        for strip, k in [(0, 'repo_type'), (1, 'repo_enable_downloads'),

                  (1, 'repo_description'), (1, 'repo_enable_locking'),

                  (1, 'repo_landing_rev'), (0, 'clone_uri'),

                  (1, 'repo_private'), (1, 'repo_enable_statistics')]:

            attr = k

            if strip:

                attr = remove_prefix(k, 'repo_')

            defaults[k] = defaults[attr]

        # fill owner

        if repo_info.user:

            defaults.update({'user': repo_info.user.username})

        else:

            replacement_user = User.query().filter(User.admin ==

                                                   True).first().username

            defaults.update({'user': replacement_user})

        # fill repository users

        for p in repo_info.repo_to_perm:

            defaults.update({'u_perm_%s' % p.user.username:

                             p.permission.permission_name})

        # fill repository groups

        for p in repo_info.users_group_to_perm:

            defaults.update({'g_perm_%s' % p.users_group.users_group_name:

                             p.permission.permission_name})

        return defaults

    def update(self, org_repo_name, **kwargs):

        try:

            cur_repo = self.get_by_repo_name(org_repo_name, cache=False)

            if 'user' in kwargs:

                cur_repo.user = User.get_by_username(kwargs['user'])

            if 'repo_group' in kwargs:

                cur_repo.group = RepoGroup.get(kwargs['repo_group'])

                      (1, 'repo_description'), (1, 'repo_enable_locking'),

                      (1, 'repo_landing_rev'), (0, 'clone_uri'),

                      (1, 'repo_private'), (1, 'repo_enable_statistics')]:

                if k in kwargs:

                    val = kwargs[k]

                    if strip:

                        k = remove_prefix(k, 'repo_')

                    setattr(cur_repo, k, val)

            new_name = cur_repo.get_new_name(kwargs['repo_name'])

            cur_repo.repo_name = new_name

            #if private flag is set, reset default permission to NONE

            if kwargs.get('repo_private'):

                EMPTY_PERM = 'repository.none'

                RepoModel().grant_user_permission(

                    repo=cur_repo, user='default', perm=EMPTY_PERM

                )

            #handle extra fields

            for field in filter(lambda k: k.startswith(RepositoryField.PREFIX), kwargs):

                k = RepositoryField.un_prefix_key(field)

                ex_field = RepositoryField.get_by_key_name(key=k, repo=cur_repo)

                if ex_field:

                    ex_field.field_value = kwargs[field]

                    self.sa.add(ex_field)

            self.sa.add(cur_repo)

            if org_repo_name != new_name:

                # rename repository

                self.__rename_repo(old=org_repo_name, new=new_name)

            return cur_repo

        except Exception:

            log.error(traceback.format_exc())

            raise

    def create_repo(self, repo_name, repo_type, description, owner,

                    private=False, clone_uri=None, repos_group=None,

                    landing_rev='tip', just_db=False, fork_of=None,

                    copy_fork_permissions=False, enable_statistics=False,

                    enable_locking=False, enable_downloads=False):

        """

        Create repository

        """

        from rhodecode.model.scm import ScmModel

        owner = self._get_user(owner)

        fork_of = self._get_repo(fork_of)

        repos_group = self._get_repo_group(repos_group)

        try:

            # repo name is just a name of repository

            # while repo_name_full is a full qualified name that is combined

            # with name and path of group

            repo_name_full = repo_name

            repo_name = repo_name.split(self.URL_SEPARATOR)[-1]

            new_repo = Repository()

            new_repo.enable_statistics = False

            new_repo.repo_name = repo_name_full

            new_repo.repo_type = repo_type

            new_repo.user = owner

            new_repo.group = repos_group

            new_repo.description = description or repo_name

            new_repo.private = private

            new_repo.clone_uri = clone_uri

            new_repo.landing_rev = landing_rev

            new_repo.enable_statistics = enable_statistics

            new_repo.enable_locking = enable_locking

            new_repo.enable_downloads = enable_downloads

            if repos_group:

                new_repo.enable_locking = repos_group.enable_locking

            if fork_of:

                parent_repo = fork_of

                new_repo.fork = parent_repo

            self.sa.add(new_repo)

            if fork_of:

                if copy_fork_permissions:

                    repo = fork_of

                    user_perms = UserRepoToPerm.query()\

                        .filter(UserRepoToPerm.repository == repo).all()

                    group_perms = UserGroupRepoToPerm.query()\

                        .filter(UserGroupRepoToPerm.repository == repo).all()

                    for perm in user_perms:

                        UserRepoToPerm.create(perm.user, new_repo,

                                              perm.permission)

                    for perm in group_perms:

                        UserGroupRepoToPerm.create(perm.users_group, new_repo,

                                                    perm.permission)

                else:

                    perm_obj = self._create_default_perms(new_repo, private)

                    self.sa.add(perm_obj)

            else:

                perm_obj = self._create_default_perms(new_repo, private)

                self.sa.add(perm_obj)

            if not just_db:

                self.__create_repo(repo_name, repo_type,

                                   repos_group,

                                   clone_uri)

                log_create_repository(new_repo.get_dict(),

                                      created_by=owner.username)

            # now automatically start following this repository as owner

            ScmModel(self.sa).toggle_following_repo(new_repo.repo_id,

                                                    owner.user_id)

            return new_repo

        except Exception:

            log.error(traceback.format_exc())

            raise

    def create(self, form_data, cur_user, just_db=False, fork=None):

        """

        Backward compatibility function, just a wrapper on top of create_repo

        :param form_data:

        :param cur_user:

        :param just_db:

        :param fork:

        """

        owner = cur_user

        repo_name = form_data['repo_name_full']

        repo_type = form_data['repo_type']

        description = form_data['repo_description']

        private = form_data['repo_private']

        clone_uri = form_data.get('clone_uri')

        repos_group = form_data['repo_group']

        landing_rev = form_data['repo_landing_rev']

        copy_fork_permissions = form_data.get('copy_permissions')

        fork_of = form_data.get('fork_parent_id')

        ## repo creation defaults, private and repo_type are filled in form

        defs = RhodeCodeSetting.get_default_repo_settings(strip_prefix=True)

        enable_statistics = defs.get('repo_enable_statistics')

        enable_locking = defs.get('repo_enable_locking')

        enable_downloads = defs.get('repo_enable_downloads')

        return self.create_repo(

            repo_name, repo_type, description, owner, private, clone_uri,

            repos_group, landing_rev, just_db, fork_of, copy_fork_permissions,

            enable_statistics, enable_locking, enable_downloads

        )

    def _update_permissions(self, repo, perms_new=None, perms_updates=None,

                            check_perms=True):

        if not perms_new:

            perms_new = []

        if not perms_updates:

            perms_updates = []

        # update permissions

        for member, perm, member_type in perms_updates:

            if member_type == 'user':

                # this updates existing one

                self.grant_user_permission(

                    repo=repo, user=member, perm=perm

                )

            else:

                #check if we have permissions to alter this usergroup

                req_perms = ('usergroup.read', 'usergroup.write', 'usergroup.admin')

                if not check_perms or HasUserGroupPermissionAny(*req_perms)(member):

                    self.grant_users_group_permission(

                        repo=repo, group_name=member, perm=perm

                    )

        # set new permissions

        for member, perm, member_type in perms_new:

            if member_type == 'user':

                self.grant_user_permission(

                    repo=repo, user=member, perm=perm

                )

            else:

                #check if we have permissions to alter this usergroup

                req_perms = ('usergroup.read', 'usergroup.write', 'usergroup.admin')

                if not check_perms or HasUserGroupPermissionAny(*req_perms)(member):

                    self.grant_users_group_permission(

                        repo=repo, group_name=member, perm=perm

                    )

    def create_fork(self, form_data, cur_user):

        """

        Simple wrapper into executing celery task for fork creation

        :param form_data:

        :param cur_user:

## -*- coding: utf-8 -*-

##

## See also repo_settings.html

##

<%inherit file="/base/base.html"/>

<%def name="title()">

    ${_('Edit repository')} ${c.repo_info.repo_name} · ${c.rhodecode_name}

</%def>

<%def name="breadcrumbs_links()">

    ${_('Settings')}

</%def>

<%def name="page_nav()">

    ${self.menu('admin')}

</%def>

<%def name="main()">

${self.context_bar('options')}

<div class="box box-left">

    <!-- box / title -->

    <div class="title">

        ${self.breadcrumbs()}

    </div>

    ${h.form(url('repo', repo_name=c.repo_info.repo_name),method='put')}

    <div class="form">

        <!-- fields -->

        <div class="fields">

            <div class="field">

                <div class="label">

                    <label for="repo_name">${_('Name')}:</label>

                </div>

                <div class="input">

                    ${h.text('repo_name',class_="medium")}

                </div>

           </div>

           <div class="field">

               <div class="label">

                   <label for="clone_uri">${_('Clone uri')}:</label>

               </div>

               <div class="input">

                   ${h.text('clone_uri',class_="medium")}

                 <span class="help-block">${_('Optional http[s] url from which repository should be cloned.')}</span>

               </div>

            </div>

            <div class="field">

                <div class="label">

                    <label for="repo_group">${_('Repository group')}:</label>

                </div>

                <div class="input">

                    ${h.select('repo_group','',c.repo_groups,class_="medium")}

                    <span class="help-block">${_('Optional select a group to put this repository into.')}</span>

                </div>

            </div>

            <div class="field">

                <div class="label">

                    <label for="repo_landing_rev">${_('Landing revision')}:</label>

                </div>

                <div class="input">

                    ${h.select('repo_landing_rev','',c.landing_revs,class_="medium")}

                    <span class="help-block">${_('Default revision for files page, downloads, whoosh and readme')}</span>

                </div>

            </div>

            <div class="field">

                <div class="label label-textarea">

                    <label for="repo_description">${_('Description')}:</label>

                </div>

                <div class="textarea text-area editor">

                    ${h.textarea('repo_description')}

                    <span class="help-block">${_('Keep it short and to the point. Use a README file for longer descriptions.')}</span>

                </div>

            </div>

            <div class="field">

                <div class="label label-checkbox">

                    <label for="repo_private">${_('Private repository')}:</label>

                </div>

                <div class="checkboxes">

                    ${h.checkbox('repo_private',value="True")}

                    <span class="help-block">${_('Private repositories are only visible to people explicitly added as collaborators.')}</span>

                </div>

            </div>

            <div class="field">

                <div class="label label-checkbox">

                    <label for="repo_enable_statistics">${_('Enable statistics')}:</label>

                </div>

                <div class="checkboxes">

                    ${h.checkbox('repo_enable_statistics',value="True")}

                    <span class="help-block">${_('Enable statistics window on summary page.')}</span>

                </div>

            </div>

            <div class="field">

                <div class="label label-checkbox">

                    <label for="repo_enable_downloads">${_('Enable downloads')}:</label>

                </div>

                <div class="checkboxes">

                    ${h.checkbox('repo_enable_downloads',value="True")}

                    <span class="help-block">${_('Enable download menu on summary page.')}</span>

                </div>

            </div>

            <div class="field">

                <div class="label label-checkbox">

                    <label for="repo_enable_locking">${_('Enable locking')}:</label>

                </div>

                <div class="checkboxes">

                    ${h.checkbox('repo_enable_locking',value="True")}

                    <span class="help-block">${_('Enable lock-by-pulling on repository.')}</span>

                </div>

            </div>

            <div class="field">

                <div class="label">

                    <label for="user">${_('Owner')}:</label>

                </div>

                <div class="input input-medium ac">

                    <div class="perm_ac">

                       ${h.text('user',class_='yui-ac-input')}

                       <span class="help-block">${_('Change owner of this repository.')}</span>

                       <div id="owner_container"></div>

                    </div>

                </div>

             </div>

            %if c.visual.repository_fields:

              ## EXTRA FIELDS

              %for field in c.repo_fields:

                <div class="field">

                    <div class="label">

                        <label for="${field.field_key_prefixed}">${field.field_label} (${field.field_key}):</label>

                    </div>

                    <div class="input input-medium">

                        ${h.text(field.field_key_prefixed, field.field_value, class_='medium')}

                        %if field.field_desc:

                          <span class="help-block">${field.field_desc}</span>

                        %endif

                    </div>

                 </div>

              %endfor

            %endif

            <div class="buttons">

              ${h.submit('save',_('Save'),class_="ui-btn large")}

              ${h.reset('reset',_('Reset'),class_="ui-btn large")}

            </div>

        </div>

    </div>

    ${h.end_form()}

</div>

<div class="box box-right">

    <div class="title">

        <h5>${_('Permissions')}</h5>

    </div>

    ${h.form(url('set_repo_perm_member', repo_name=c.repo_info.repo_name),method='post')}

    <div class="form">

       <div class="fields">

            <div class="field">

                <div class="label">

                    <label for="input">${_('Permissions')}:</label>

                </div>

                <div class="input">

                    ${h.hidden('repo_private')}

                    <%include file="repo_edit_perms.html"/>

                </div>

            </div>

            <div class="buttons">

              ${h.submit('save',_('Save'),class_="ui-btn large")}

              ${h.reset('reset',_('Reset'),class_="ui-btn large")}

            </div>

       </div>

    </div>

    ${h.end_form()}

</div>

<div class="box box-right"  style="clear:right">

    <div class="title">

        <h5>${_('Advanced settings')}</h5>

    </div>

    <h3>${_('Statistics')}</h3>

    ${h.form(url('repo_stats', repo_name=c.repo_info.repo_name),method='delete')}

    <div class="form">

       <div class="fields">

           ${h.submit('reset_stats_%s' % c.repo_info.repo_name,_('Reset current statistics'),class_="ui-btn",onclick="return confirm('"+_('Confirm to remove current statistics')+"');")}

           <div class="field" style="border:none;color:#888">

           <ul>

                <li>${_('Fetched to rev')}: ${c.stats_revision}/${c.repo_last_rev}</li>

                <li>${_('Stats gathered')}: ${c.stats_percentage}%</li>

           </ul>

           </div>

       </div>

    </div>

    ${h.end_form()}

    %if c.repo_info.clone_uri:

    <h3>${_('Remote')}</h3>

    ${h.form(url('repo_pull', repo_name=c.repo_info.repo_name),method='put')}

    <div class="form">

       <div class="fields">

           ${h.submit('remote_pull_%s' % c.repo_info.repo_name,_('Pull changes from remote location'),class_="ui-btn",onclick="return confirm('"+_('Confirm to pull changes from remote side')+"');")}

           <div class="field" style="border:none">

           <ul>

                <li><a href="${c.repo_info.clone_uri}">${c.repo_info.clone_uri}</a></li>

           </ul>

           </div>

       </div>

    </div>

    ${h.end_form()}

    %endif

    <h3>${_('Cache')}</h3>

    ${h.form(url('repo_cache', repo_name=c.repo_info.repo_name),method='delete')}

    <div class="form">

       <div class="fields">

           ${h.submit('reset_cache_%s' % c.repo_info.repo_name,_('Invalidate repository cache'),class_="ui-btn",onclick="return confirm('"+_('Confirm to invalidate repository cache')+"');")}

          <div class="field" style="border:none;color:#888">

          <ul>

              <li>${_('Manually invalidate cache for this repository. On first access repository will be cached again')}

              </li>

          </ul>

          </div>

          <div class="field" style="border:none;">

            ${_('List of cached values')}

               <table>

               <tr>

                <th>${_('Prefix')}</th>

                <th>${_('Key')}</th>

                <th>${_('Active')}</th>

                </tr>

              %for cache in c.repo_info.cache_keys:

                  <tr>

                    <td>${cache.get_prefix() or '-'}</td>

                    <td>${cache.cache_key}</td>

                    <td>${h.boolicon(cache.cache_active)}</td>

                  </tr>

              %endfor

              </table>

          </div>

       </div>

    </div>

    ${h.end_form()}

    <h3>${_('Public journal')}</h3>

    ${h.form(url('repo_public_journal', repo_name=c.repo_info.repo_name),method='put')}

    <div class="form">

      ${h.hidden('auth_token',str(h.get_token()))}

      <div class="field">

      %if c.in_public_journal:

        ${h.submit('set_public_%s' % c.repo_info.repo_name,_('Remove from public journal'),class_="ui-btn")}

      %else: