from kallithea.lib.auth import LoginRequired, HasRepoPermissionLevelDecorator

from kallithea.lib.base import BaseRepoController, render

from kallithea.lib.page import Page

from kallithea.lib.utils2 import safe_int

from kallithea.model.db import UserFollowing

log = logging.getLogger(__name__)

class FollowersController(BaseRepoController):

    @LoginRequired()

    @HasRepoPermissionLevelDecorator('read')

    def followers(self, repo_name):

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

        repo_id = c.db_repo.repo_id

        d = UserFollowing.get_repo_followers(repo_id) \

            .order_by(UserFollowing.follows_from)

        c.followers_pager = Page(d, page=p, items_per_page=20)

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

            return render('/followers/followers_data.html')

from kallithea.lib.page import Page

from kallithea.lib.utils2 import safe_int

from kallithea.model.db import Repository, UserFollowing, User, Ui

from kallithea.model.repo import RepoModel

from kallithea.model.forms import RepoForkForm

from kallithea.model.scm import ScmModel, AvailableRepoGroupChoices

log = logging.getLogger(__name__)

class ForksController(BaseRepoController):

    def __load_defaults(self):

        if HasPermissionAny('hg.create.write_on_repogroup.true')():

            repo_group_perm_level = 'write'

        else:

            repo_group_perm_level = 'admin'

        c.repo_groups = AvailableRepoGroupChoices(['hg.create.repository'], repo_group_perm_level)

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

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

    def __load_data(self):

from kallithea.lib.utils import conditional_cache

from kallithea.lib.auth import LoginRequired, HasRepoPermissionLevelDecorator

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

from kallithea.model.db import Repository, RepoGroup

from kallithea.model.repo import RepoModel

log = logging.getLogger(__name__)

class HomeController(BaseController):

    def about(self):

        return render('/about.html')

    @LoginRequired()

    def index(self):

        c.groups = self.scm_model.get_repo_groups()

        c.group = None

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

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

                                                   admin=False, short_name=True)

from kallithea.model.db import User, Setting

from kallithea.model.forms import \

    LoginForm, RegisterForm, PasswordResetRequestForm, PasswordResetConfirmationForm

from kallithea.model.user import UserModel

from kallithea.model.meta import Session

log = logging.getLogger(__name__)

class LoginController(BaseController):

    def _validate_came_from(self, came_from,

            _re=re.compile(r"/(?!/)[-!#$%&'()*+,./:;=?@_~0-9A-Za-z]*$")):

        """Return True if came_from is valid and can and should be used.

        Determines if a URI reference is valid and relative to the origin;

        or in RFC 3986 terms, whether it matches this production:

          origin-relative-ref = path-absolute [ "?" query ] [ "#" fragment ]

        with the exception that '%' escapes are not validated and '#' is

        allowed inside the fragment part.

        """

from kallithea.lib.base import BaseRepoController, render

from kallithea.lib.indexers import CHGSETS_SCHEMA, SCHEMA, CHGSET_IDX_NAME, \

    IDX_NAME, WhooshResultWrapper

from kallithea.lib.page import Page

from kallithea.lib.utils2 import safe_str, safe_int

from kallithea.model.repo import RepoModel

log = logging.getLogger(__name__)

class SearchController(BaseRepoController):

    @LoginRequired()

    def index(self, repo_name=None):

        c.repo_name = repo_name

        c.formated_results = []

        c.runtime = ''

        c.cur_query = request.GET.get('q', None)

        c.cur_type = request.GET.get('type', 'content')

        c.cur_search = search_type = {'content': 'content',

                                      'commit': 'message',

                                      'path': 'path',

                                      'repository': 'repository'

                                      }.get(c.cur_type, 'content')

from kallithea.lib.vcs.nodes import FileNode

from kallithea.controllers.changelog import _load_changelog_summary

log = logging.getLogger(__name__)

README_FILES = [''.join([x[0][0], x[1][0]]) for x in

                    sorted(list(itertools.product(ALL_READMES, ALL_EXTS)),

                           key=lambda y:y[0][1] + y[1][1])]

class SummaryController(BaseRepoController):

    def __get_readme_data(self, db_repo):

        repo_name = db_repo.repo_name

        log.debug('Looking for README file')

        @cache_region('long_term', '_get_readme_from_cache')

        def _get_readme_from_cache(key, kind):

            readme_data = None

            readme_file = None

            try:

                # gets the landing revision! or tip if fails

                cs = db_repo.get_landing_changeset()

                if isinstance(cs, EmptyChangeset):