class ReposController(BaseRepoController):

    @LoginRequired(allow_default_user=True)

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

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

    def _load_repo(self):

        repo_obj = c.db_repo

        if repo_obj is None:

        return repo_obj

    def __load_defaults(self, repo=None):

        extras = [] if repo is None else [repo.group]

        c.repo_groups = AvailableRepoGroupChoices('write', extras)

        c.landing_revs_choices, c.landing_revs = ScmModel().get_repo_landing_revs(repo)

    def __load_data(self):

        """

        except Exception:

            log.error(traceback.format_exc())

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

                    % repo_name, category='error')

        raise HTTPFound(location=url('edit_repo', repo_name=changed_name))

    @HasRepoPermissionLevelDecorator('admin')

    def delete(self, repo_name):

        repo_model = RepoModel()

        repo = repo_model.get_by_repo_name(repo_name)

        if not repo:

        try:

            _forks = repo.forks.count()

            handle_forks = None

            if _forks and request.POST.get('forks'):

                do = request.POST['forks']

                if do == 'detach_forks':

                    handle_forks = 'detach'

                    h.flash(_('Detached %s forks') % _forks, category='success')

                elif do == 'delete_forks':

                    handle_forks = 'delete'

                    h.flash(_('Deleted %s forks') % _forks, category='success')

            repo_model.delete(repo, forks=handle_forks)

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

from tg import tmpl_context as c

from tg.i18n import ugettext as _

import kallithea

import kallithea.lib.helpers as h

from kallithea.lib.auth import HasPermissionAnyDecorator, HasRepoPermissionLevel, HasRepoPermissionLevelDecorator, LoginRequired

from kallithea.lib.base import BaseRepoController, render

from kallithea.lib.page import Page

from kallithea.lib.utils2 import safe_int

from kallithea.model import db

from kallithea.model.forms import RepoForkForm

from kallithea.model.repo import RepoModel

from kallithea.model.scm import AvailableRepoGroupChoices, ScmModel

log = logging.getLogger(__name__)

class ForksController(BaseRepoController):

    def __load_defaults(self):

        c.can_update = db.Ui.get_by_key('hooks', db.Ui.HOOK_UPDATE).ui_active

    def __load_data(self):

        """

        Load defaults settings for edit, and update

        """

        self.__load_defaults()

        c.repo_info = c.db_repo

        repo = c.db_repo.scm_instance

        if c.repo_info is None:

        c.default_user_id = kallithea.DEFAULT_USER_ID

        c.in_public_journal = db.UserFollowing.query() \

            .filter(db.UserFollowing.user_id == c.default_user_id) \

            .filter(db.UserFollowing.follows_repository == c.repo_info).scalar()

        if c.repo_info.stats:

            last_rev = c.repo_info.stats.stat_on_revision + 1

        else:

            last_rev = 0

        c.stats_revision = last_rev

        if request.environ.get('HTTP_X_PARTIAL_XHR'):

            return render('/forks/forks_data.html')

        return render('/forks/forks.html')

    @LoginRequired()

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

    @HasRepoPermissionLevelDecorator('read')

    def fork(self, repo_name):

        c.repo_info = db.Repository.get_by_repo_name(repo_name)

        if not c.repo_info:

        defaults = self.__load_data()

        return htmlfill.render(

            render('forks/fork.html'),

            defaults=defaults,

            encoding="UTF-8",

            force_defaults=False)

    @LoginRequired()

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

    @HasRepoPermissionLevelDecorator('read')

            date:[20120101100000 TO 20120102]

        Generate wildcards using '*' character:

            "repository:vcs*" - search everything starting with 'vcs'

            "repository:*vcs*" - search for repository containing 'vcs'

        Optional AND / OR operators in queries

            "repository:vcs OR repository:test"

            "username:test AND repository:test*"

    '''))

def ip_range(ip_addr):

    s, e = db.UserIpMap._get_ip_range(ip_addr)

    return '%s - %s' % (s, e)

session_csrf_secret_name = "_session_csrf_secret_token"

def session_csrf_secret_token():

    """Return (and create) the current session's CSRF protection token."""

    if not session_csrf_secret_name in session:

        session[session_csrf_secret_name] = str(random.getrandbits(128))

        session.save()