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

# This program is free software: you can redistribute it and/or modify

# it under the terms of the GNU General Public License as published by

# the Free Software Foundation, either version 3 of the License, or

# (at your option) any later version.

#

# 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/>.

"""

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

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

:created_on: Feb 9, 2013

:author: marcink

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

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

"""

import datetime

import os

import re

import shutil

import click

import kallithea.bin.kallithea_cli_base as cli_base

from kallithea.lib.utils import REMOVED_REPO_PAT, repo2db_mapper

from kallithea.model.db import Repository, Ui

from kallithea.model.meta import Session

from kallithea.model.scm import ScmModel

@cli_base.register_command(config_file_initialize_app=True)

@click.option('--remove-missing', is_flag=True,

        help='Remove missing repositories from the Kallithea database.')

def repo_scan(remove_missing):

    """Scan filesystem for repositories.

    Search the configured repository root for new repositories and add them

    into Kallithea.

    Additionally, report repositories that were previously known to Kallithea

    but are no longer present on the filesystem. If option --remove-missing is

    given, remove the missing repositories from the Kallithea database.

    """

    click.echo('Now scanning root location for new repos ...')

    added, removed = repo2db_mapper(ScmModel().repo_scan(),

                                    remove_obsolete=remove_missing)

    click.echo('Scan completed.')

    if added:

        click.echo('Added: %s' % ', '.join(added))

    if removed:

        click.echo('%s: %s' % ('Removed' if remove_missing else 'Missing',

                          ', '.join(removed)))

@cli_base.register_command(config_file_initialize_app=True)

@click.argument('repositories', nargs=-1)

def repo_update_metadata(repositories):

    """

    Update repository metadata in database from repository content.

    In normal operation, Kallithea will keep caches up-to-date

    automatically. However, if repositories are externally modified, e.g. by

    a direct push via the filesystem rather than via a Kallithea URL,

    Kallithea is not aware of it. In this case, you should manually run this

    command to update the repository cache.

    If no repositories are specified, the caches of all repositories are

    updated.

    """

    if not repositories:

        repo_list = Repository.query().all()

    else:

        repo_list = list(Repository.query()

                        .filter(Repository.repo_name.in_(repo_names)))

    for repo in repo_list:

        # update latest revision metadata in database

        repo.update_changeset_cache()

        # invalidate in-memory VCS object cache... will be repopulated on

        # first access

        repo.set_invalidate()

    Session().commit()

    click.echo('Updated database with information about latest change in the following %s repositories:' % (len(repo_list)))

    click.echo('\n'.join(repo.repo_name for repo in repo_list))

@cli_base.register_command(config_file_initialize_app=True)

@click.option('--ask/--no-ask', default=True, help='Ask for confirmation or not. Default is --ask.')

@click.option('--older-than',

        help="""Only purge repositories that have been removed at least the given time ago.

        For example, '--older-than=30d' purges repositories deleted 30 days ago or longer.

        Possible suffixes: d (days), h (hours), m (minutes), s (seconds).""")

def repo_purge_deleted(ask, older_than):

    """Purge backups of deleted repositories.

    When a repository is deleted via the Kallithea web interface, the actual

    data is still present on the filesystem but set aside using a special name.

    This command allows to delete these files permanently.

    """

    def _parse_older_than(val):

        regex = re.compile(r'((?P<days>\d+?)d)?((?P<hours>\d+?)h)?((?P<minutes>\d+?)m)?((?P<seconds>\d+?)s)?')

        parts = regex.match(val)

        if not parts:

            return

        parts = parts.groupdict()

        time_params = {}

        for name, param in parts.items():

            if param:

                time_params[name] = int(param)

        return datetime.timedelta(**time_params)

    def _extract_date(name):

        """

        Extract the date part from rm__<date> pattern of removed repos,

        and convert it to datetime object

        :param name:

        """

        date_part = name[4:19]  # 4:19 since we don't parse milliseconds

        return datetime.datetime.strptime(date_part, '%Y%m%d_%H%M%S')

    repos_location = Ui.get_repos_location()

    to_remove = []

    for dn_, dirs, f in os.walk(safe_str(repos_location)):

        alldirs = list(dirs)

        del dirs[:]

        if ('.hg' in alldirs or

            '.git' in alldirs or

            '.svn' in alldirs or

            'objects' in alldirs and ('refs' in alldirs or 'packed-refs' in f)

        ):

            continue

        for loc in alldirs:

            if REMOVED_REPO_PAT.match(loc):

                to_remove.append([os.path.join(dn_, loc),

                                  _extract_date(loc)])

            else:

                dirs.append(loc)

        if dirs:

            click.echo('Scanning: %s' % dn_)

    if not to_remove:

        click.echo('There are no deleted repositories.')

        return

    # filter older than (if present)!

    if older_than:

        now = datetime.datetime.now()

        to_remove_filtered = []

        older_than_date = _parse_older_than(older_than)

        for name, date_ in to_remove:

            repo_age = now - date_

            if repo_age > older_than_date:

                to_remove_filtered.append([name, date_])

        to_remove = to_remove_filtered

        if not to_remove:

            click.echo('There are no deleted repositories older than %s (%s)'

                    % (older_than, older_than_date))

            return

        click.echo('Considering %s deleted repositories older than %s (%s).'

            % (len(to_remove), older_than, older_than_date))

    else:

        click.echo('Considering %s deleted repositories.' % len(to_remove))

    if not ask:

        remove = True

    else:

        remove = ask_ok('The following repositories will be removed completely:\n%s\n'

                'Do you want to proceed? [y/n] '

                % '\n'.join(['%s deleted on %s' % (safe_str(x[0]), safe_str(x[1]))

                                     for x in to_remove]))

    if remove:

        for path, date_ in to_remove:

            click.echo('Purging repository %s' % path)

            shutil.rmtree(path)

    else:

        click.echo('Nothing done, exiting...')

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

# This program is free software: you can redistribute it and/or modify

# it under the terms of the GNU General Public License as published by

# the Free Software Foundation, either version 3 of the License, or

# (at your option) any later version.

#

# 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.admin.gists

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

gist controller for Kallithea

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: May 9, 2013

:author: marcink

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

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

"""

import logging

import traceback

import formencode.htmlfill

from sqlalchemy.sql.expression import or_

from tg import request, response

from tg import tmpl_context as c

from tg.i18n import ugettext as _

from webob.exc import HTTPForbidden, HTTPFound, HTTPNotFound

from kallithea.config.routing import url

from kallithea.lib import helpers as h

from kallithea.lib.auth import LoginRequired

from kallithea.lib.base import BaseController, jsonify, render

from kallithea.lib.page import Page

from kallithea.lib.utils2 import safe_int, safe_unicode, time_to_datetime

from kallithea.lib.vcs.exceptions import NodeNotChangedError, VCSError

from kallithea.model.db import Gist

from kallithea.model.forms import GistForm

from kallithea.model.gist import GistModel

from kallithea.model.meta import Session

log = logging.getLogger(__name__)

class GistsController(BaseController):

    """REST Controller styled on the Atom Publishing Protocol"""

    def __load_defaults(self, extra_values=None):

        c.lifetime_values = [

            (str(-1), _('Forever')),

            (str(5), _('5 minutes')),

            (str(60), _('1 hour')),

            (str(60 * 24), _('1 day')),

            (str(60 * 24 * 30), _('1 month')),

        ]

        if extra_values:

            c.lifetime_values.append(extra_values)

        c.lifetime_options = [(c.lifetime_values, _("Lifetime"))]

    @LoginRequired(allow_default_user=True)

    def index(self):

        not_default_user = not request.authuser.is_default_user

        c.show_private = request.GET.get('private') and not_default_user

        c.show_public = request.GET.get('public') and not_default_user

        url_params = {}

        if c.show_public:

            url_params['public'] = 1

        elif c.show_private:

            url_params['private'] = 1

        gists = Gist().query() \

            .filter_by(is_expired=False) \

            .order_by(Gist.created_on.desc())

        # MY private

        if c.show_private and not c.show_public:

            gists = gists.filter(Gist.gist_type == Gist.GIST_PRIVATE) \

                             .filter(Gist.owner_id == request.authuser.user_id)

        # MY public

        elif c.show_public and not c.show_private:

            gists = gists.filter(Gist.gist_type == Gist.GIST_PUBLIC) \

                             .filter(Gist.owner_id == request.authuser.user_id)

        # MY public+private

        elif c.show_private and c.show_public:

            gists = gists.filter(or_(Gist.gist_type == Gist.GIST_PUBLIC,

                                     Gist.gist_type == Gist.GIST_PRIVATE)) \

                             .filter(Gist.owner_id == request.authuser.user_id)

        # default show ALL public gists

        if not c.show_public and not c.show_private:

            gists = gists.filter(Gist.gist_type == Gist.GIST_PUBLIC)

        c.gists = gists

        p = safe_int(request.GET.get('page'), 1)

        c.gists_pager = Page(c.gists, page=p, items_per_page=10,

                             **url_params)

        return render('admin/gists/index.html')

    @LoginRequired()

    def create(self):

        self.__load_defaults()

        gist_form = GistForm([x[0] for x in c.lifetime_values])()

        try:

            form_result = gist_form.to_python(dict(request.POST))

            # TODO: multiple files support, from the form

            filename = form_result['filename'] or Gist.DEFAULT_FILENAME

            nodes = {

                filename: {

                    'content': form_result['content'],

                    'lexer': form_result['mimetype']  # None is autodetect

                }

            }

            _public = form_result['public']

            gist_type = Gist.GIST_PUBLIC if _public else Gist.GIST_PRIVATE

            gist = GistModel().create(

                description=form_result['description'],

                owner=request.authuser.user_id,

                ip_addr=request.ip_addr,

                gist_mapping=nodes,

                gist_type=gist_type,

                lifetime=form_result['lifetime']

            )

            Session().commit()

            new_gist_id = gist.gist_access_id

        except formencode.Invalid as errors:

            defaults = errors.value

            return formencode.htmlfill.render(

                render('admin/gists/new.html'),

                defaults=defaults,

                errors=errors.error_dict or {},

                prefix_error=False,

                encoding="UTF-8",

                force_defaults=False)

        except Exception as e:

            log.error(traceback.format_exc())

            h.flash(_('Error occurred during gist creation'), category='error')

            raise HTTPFound(location=url('new_gist'))

        raise HTTPFound(location=url('gist', gist_id=new_gist_id))

    @LoginRequired()

    def new(self, format='html'):

        self.__load_defaults()

        return render('admin/gists/new.html')

    @LoginRequired()

    def delete(self, gist_id):

        gist = GistModel().get_gist(gist_id)

        owner = gist.owner_id == request.authuser.user_id

        if h.HasPermissionAny('hg.admin')() or owner:

            GistModel().delete(gist)

            Session().commit()

            h.flash(_('Deleted gist %s') % gist.gist_access_id, category='success')

        else:

            raise HTTPForbidden()

        raise HTTPFound(location=url('gists'))

    @LoginRequired(allow_default_user=True)

    def show(self, gist_id, revision='tip', format='html', f_path=None):

        c.gist = Gist.get_or_404(gist_id)

        if c.gist.is_expired:

            log.error('Gist expired at %s',

                      time_to_datetime(c.gist.gist_expires))

            raise HTTPNotFound()

        try:

            c.file_changeset, c.files = GistModel().get_gist_files(gist_id,

                                                            revision=revision)

        except VCSError:

            log.error(traceback.format_exc())

            raise HTTPNotFound()

        if format == 'raw':

            response.content_type = 'text/plain'

            return content

        return render('admin/gists/show.html')

    @LoginRequired()

    def edit(self, gist_id, format='html'):

        c.gist = Gist.get_or_404(gist_id)

        if c.gist.is_expired:

            log.error('Gist expired at %s',

                      time_to_datetime(c.gist.gist_expires))

            raise HTTPNotFound()

        try:

            c.file_changeset, c.files = GistModel().get_gist_files(gist_id)

        except VCSError:

            log.error(traceback.format_exc())

            raise HTTPNotFound()

        self.__load_defaults(extra_values=('0', _('Unmodified')))

        rendered = render('admin/gists/edit.html')

        if request.POST:

            rpost = request.POST

            nodes = {}

            for org_filename, filename, mimetype, content in zip(

                                                    rpost.getall('org_files'),

                                                    rpost.getall('files'),

                                                    rpost.getall('mimetypes'),

                                                    rpost.getall('contents')):

                nodes[org_filename] = {

                    'org_filename': org_filename,

                    'filename': filename,

                    'content': content,

                    'lexer': mimetype,

                }

            try:

                GistModel().update(

                    gist=c.gist,

                    description=rpost['description'],

                    owner=c.gist.owner, # FIXME: request.authuser.user_id ?

                    ip_addr=request.ip_addr,

                    gist_mapping=nodes,

                    gist_type=c.gist.gist_type,

                    lifetime=rpost['lifetime']

                )

                Session().commit()

                h.flash(_('Successfully updated gist content'), category='success')

            except NodeNotChangedError:

                # raised if nothing was changed in repo itself. We anyway then

                # store only DB stuff for gist

                Session().commit()

                h.flash(_('Successfully updated gist data'), category='success')

            except Exception:

                log.error(traceback.format_exc())

                h.flash(_('Error occurred during update of gist %s') % gist_id,

                        category='error')

            raise HTTPFound(location=url('gist', gist_id=gist_id))

        return rendered

    @LoginRequired()

    @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:

            log.error('Last revision %s is different than submitted %s',

                      revision, last_rev)

            # our gist has newer version than we

            success = False

        return {'success': success}

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

# This program is free software: you can redistribute it and/or modify

# it under the terms of the GNU General Public License as published by

# the Free Software Foundation, either version 3 of the License, or

# (at your option) any later version.

#

# 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.admin.repo_groups

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

Repository groups controller for Kallithea

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: Mar 23, 2010

:author: marcink

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

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

"""

import logging

import traceback

import formencode

from formencode import htmlfill

from tg import app_globals, request

from tg import tmpl_context as c

from tg.i18n import ugettext as _

from tg.i18n import ungettext

from webob.exc import HTTPForbidden, HTTPFound, HTTPInternalServerError, HTTPNotFound

from kallithea.config.routing import url

from kallithea.lib import helpers as h

from kallithea.lib.auth import HasPermissionAny, HasRepoGroupPermissionLevel, HasRepoGroupPermissionLevelDecorator, LoginRequired

from kallithea.lib.base import BaseController, render

from kallithea.model.db import RepoGroup, Repository

from kallithea.model.forms import RepoGroupForm, RepoGroupPermsForm

from kallithea.model.meta import Session

from kallithea.model.repo import RepoModel

from kallithea.model.repo_group import RepoGroupModel

from kallithea.model.scm import AvailableRepoGroupChoices, RepoGroupList

log = logging.getLogger(__name__)

class RepoGroupsController(BaseController):

    @LoginRequired(allow_default_user=True)

    def _before(self, *args, **kwargs):

        super(RepoGroupsController, self)._before(*args, **kwargs)

    def __load_defaults(self, extras=(), exclude=()):

        """extras is used for keeping current parent ignoring permissions

        exclude is used for not moving group to itself TODO: also exclude descendants

        Note: only admin can create top level groups

        """

        repo_groups = AvailableRepoGroupChoices([], 'admin', extras)

        exclude_group_ids = set(rg.group_id for rg in exclude)

        c.repo_groups = [rg for rg in repo_groups

                         if rg[0] not in exclude_group_ids]

    def __load_data(self, group_id):

        """

        Load defaults settings for edit, and update

        :param group_id:

        """

        repo_group = RepoGroup.get_or_404(group_id)

        data = repo_group.get_dict()

        data['group_name'] = repo_group.name

        # fill repository group users

        for p in repo_group.repo_group_to_perm:

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

                             p.permission.permission_name})

        # fill repository group groups

        for p in repo_group.users_group_to_perm:

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

                             p.permission.permission_name})

        return data

    def _revoke_perms_on_yourself(self, form_result):

        _up = [u for u in form_result['perms_updates'] if request.authuser.username == u[0]]

        _new = [u for u in form_result['perms_new'] if request.authuser.username == u[0]]

        if _new and _new[0][1] != 'group.admin' or _up and _up[0][1] != 'group.admin':

            return True

        return False

    def index(self, format='html'):

        _list = RepoGroup.query(sorted=True).all()

        group_iter = RepoGroupList(_list, perm_level='admin')

        repo_groups_data = []

        total_records = len(group_iter)

        _tmpl_lookup = app_globals.mako_lookup

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

        repo_group_name = lambda repo_group_name, children_groups: (

            template.get_def("repo_group_name")

            .render_unicode(repo_group_name, children_groups, _=_, h=h, c=c)

        )

        repo_group_actions = lambda repo_group_id, repo_group_name, gr_count: (

            template.get_def("repo_group_actions")

            .render_unicode(repo_group_id, repo_group_name, gr_count, _=_, h=h, c=c,

                    ungettext=ungettext)

        )

        for repo_gr in group_iter:

            repo_count = repo_gr.repositories.count()

            repo_groups_data.append({

                "raw_name": repo_gr.group_name,

                "group_name": repo_group_name(repo_gr.group_name, children_groups),

                "desc": h.escape(repo_gr.group_description),

                "repos": repo_count,

                "owner": h.person(repo_gr.owner),

                "action": repo_group_actions(repo_gr.group_id, repo_gr.group_name,

                                             repo_count)

            })

        c.data = {

            "sort": None,

            "dir": "asc",

            "records": repo_groups_data

        }

        return render('admin/repo_groups/repo_groups.html')

    def create(self):

        self.__load_defaults()

        # permissions for can create group based on parent_id are checked

        # here in the Form

        repo_group_form = RepoGroupForm(repo_groups=c.repo_groups)

        form_result = None

        try:

            form_result = repo_group_form.to_python(dict(request.POST))

            gr = RepoGroupModel().create(

                group_name=form_result['group_name'],

                group_description=form_result['group_description'],

                parent=form_result['parent_group_id'],

                owner=request.authuser.user_id, # TODO: make editable

                copy_permissions=form_result['group_copy_permissions']

            )

            Session().commit()

            # TODO: in future action_logger(, '', '', '')

        except formencode.Invalid as errors:

            return htmlfill.render(

                render('admin/repo_groups/repo_group_add.html'),

                defaults=errors.value,

                errors=errors.error_dict or {},

                prefix_error=False,

                encoding="UTF-8",

                force_defaults=False)

        except Exception:

            log.error(traceback.format_exc())

            h.flash(_('Error occurred during creation of repository group %s')

                    % request.POST.get('group_name'), category='error')

            if form_result is None:

                raise

            parent_group_id = form_result['parent_group_id']

            # TODO: maybe we should get back to the main view, not the admin one

            raise HTTPFound(location=url('repos_groups', parent_group=parent_group_id))

        h.flash(_('Created repository group %s') % gr.group_name,

                category='success')

        raise HTTPFound(location=url('repos_group_home', group_name=gr.group_name))

    def new(self):

        if HasPermissionAny('hg.admin')('group create'):

            # we're global admin, we're ok and we can create TOP level groups

            pass

        else:

            # we pass in parent group into creation form, thus we know

            # what would be the group, we can check perms here !

            group_id = safe_int(request.GET.get('parent_group'))

            group = RepoGroup.get(group_id) if group_id else None

            group_name = group.group_name if group else None

            if HasRepoGroupPermissionLevel('admin')(group_name, 'group create'):

                pass

            else:

                raise HTTPForbidden()

        self.__load_defaults()

        return render('admin/repo_groups/repo_group_add.html')

    @HasRepoGroupPermissionLevelDecorator('admin')

    def update(self, group_name):

        c.repo_group = RepoGroup.guess_instance(group_name)

        self.__load_defaults(extras=[c.repo_group.parent_group],

                             exclude=[c.repo_group])

        # TODO: kill allow_empty_group - it is only used for redundant form validation!

        if HasPermissionAny('hg.admin')('group edit'):

            # we're global admin, we're ok and we can create TOP level groups

            allow_empty_group = True

        elif not c.repo_group.parent_group:

            allow_empty_group = True

        else:

            allow_empty_group = False

        repo_group_form = RepoGroupForm(

            edit=True,

            old_data=c.repo_group.get_dict(),

            repo_groups=c.repo_groups,

            can_create_in_root=allow_empty_group,

        )()

        try:

            form_result = repo_group_form.to_python(dict(request.POST))

            new_gr = RepoGroupModel().update(group_name, form_result)

            Session().commit()

            h.flash(_('Updated repository group %s')

                    % form_result['group_name'], category='success')

            # we now have new name !

            group_name = new_gr.group_name

            # TODO: in future action_logger(, '', '', '')

        except formencode.Invalid as errors:

            c.active = 'settings'

            return htmlfill.render(

                render('admin/repo_groups/repo_group_edit.html'),

                defaults=errors.value,

                errors=errors.error_dict or {},

                prefix_error=False,

                encoding="UTF-8",

                force_defaults=False)

        except Exception:

            log.error(traceback.format_exc())

            h.flash(_('Error occurred during update of repository group %s')

                    % request.POST.get('group_name'), category='error')

        raise HTTPFound(location=url('edit_repo_group', group_name=group_name))

    @HasRepoGroupPermissionLevelDecorator('admin')

    def delete(self, group_name):

        gr = c.repo_group = RepoGroup.guess_instance(group_name)

        repos = gr.repositories.all()

        if repos:

            h.flash(_('This group contains %s repositories and cannot be '

                      'deleted') % len(repos), category='warning')

            raise HTTPFound(location=url('repos_groups'))

        children = gr.children.all()

        if children:

            h.flash(_('This group contains %s subgroups and cannot be deleted'

                      % (len(children))), category='warning')

            raise HTTPFound(location=url('repos_groups'))

        try:

            RepoGroupModel().delete(group_name)

            Session().commit()

            h.flash(_('Removed repository group %s') % group_name,

                    category='success')

            # TODO: in future action_logger(, '', '', '')

        except Exception:

            log.error(traceback.format_exc())

            h.flash(_('Error occurred during deletion of repository group %s')

                    % group_name, category='error')

        if gr.parent_group:

            raise HTTPFound(location=url('repos_group_home', group_name=gr.parent_group.group_name))

        raise HTTPFound(location=url('repos_groups'))

    def show_by_name(self, group_name):

        """

        This is a proxy that does a lookup group_name -> id, and shows

        the group by id view instead

        """

        group_name = group_name.rstrip('/')

        id_ = RepoGroup.get_by_group_name(group_name)

        if id_:

            return self.show(group_name)

        raise HTTPNotFound

    @HasRepoGroupPermissionLevelDecorator('read')

    def show(self, group_name):

        c.active = 'settings'

        c.group = c.repo_group = RepoGroup.guess_instance(group_name)

        groups = RepoGroup.query(sorted=True).filter_by(parent_group=c.group).all()

        repo_groups_list = self.scm_model.get_repo_groups(groups)

        repos_list = Repository.query(sorted=True).filter_by(group=c.group).all()

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

                                               repo_groups_list=repo_groups_list,

                                               short_name=True)

        return render('admin/repo_groups/repo_group_show.html')

    @HasRepoGroupPermissionLevelDecorator('admin')

    def edit(self, group_name):

        c.active = 'settings'

        c.repo_group = RepoGroup.guess_instance(group_name)

        self.__load_defaults(extras=[c.repo_group.parent_group],

                             exclude=[c.repo_group])

        defaults = self.__load_data(c.repo_group.group_id)

        return htmlfill.render(

            render('admin/repo_groups/repo_group_edit.html'),

            defaults=defaults,

            encoding="UTF-8",

    ig_ws_global = GET.get('ignorews')

    ig_ws = [k for k in GET.getall(fid) if k.startswith('WS')]

    if ig_ws:

        try:

            return int(ig_ws[0].split(':')[-1])

        except ValueError:

            raise HTTPBadRequest()

    return ig_ws_global

def _ignorews_url(GET, fileid=None):

    fileid = str(fileid) if fileid else None

    params = defaultdict(list)

    _update_with_GET(params, GET)

    lbl = _('Show whitespace')

    ig_ws = get_ignore_ws(fileid, GET)

    ln_ctx = get_line_ctx(fileid, GET)

    # global option

    if fileid is None:

        if ig_ws is None:

            params['ignorews'] += [1]

            lbl = _('Ignore whitespace')

        ctx_key = 'context'

        ctx_val = ln_ctx

    # per file options

    else:

        if ig_ws is None:

            params[fileid] += ['WS:1']

            lbl = _('Ignore whitespace')

        ctx_key = fileid

        ctx_val = 'C:%s' % ln_ctx

    # if we have passed in ln_ctx pass it along to our params

    if ln_ctx:

        params[ctx_key] += [ctx_val]

    params['anchor'] = fileid

    icon = h.literal('<i class="icon-strike"></i>')

    return h.link_to(icon, h.url.current(**params), title=lbl, **{'data-toggle': 'tooltip'})

def get_line_ctx(fid, GET):

    ln_ctx_global = GET.get('context')

    if fid:

        ln_ctx = [k for k in GET.getall(fid) if k.startswith('C')]

    else:

        _ln_ctx = [k for k in GET if k.startswith('C')]

        ln_ctx = GET.get(_ln_ctx[0]) if _ln_ctx else ln_ctx_global

        if ln_ctx:

            ln_ctx = [ln_ctx]

    if ln_ctx:

        retval = ln_ctx[0].split(':')[-1]

    else:

        retval = ln_ctx_global

    try:

        return int(retval)

    except Exception:

        return 3

def _context_url(GET, fileid=None):

    """

    Generates url for context lines

    :param fileid:

    """

    fileid = str(fileid) if fileid else None

    ig_ws = get_ignore_ws(fileid, GET)

    ln_ctx = (get_line_ctx(fileid, GET) or 3) * 2

    params = defaultdict(list)

    _update_with_GET(params, GET)

    # global option

    if fileid is None:

        if ln_ctx > 0:

            params['context'] += [ln_ctx]