from kallithea.lib import helpers

from kallithea.lib.auth import set_available_permissions

    load_rcextensions, check_git_version, set_vcs_config, set_indexer_config

from kallithea.lib.utils2 import engine_from_config, str2bool

from kallithea.lib.db_manage import DbManage

    @HasPermissionAllDecorator('hg.admin')

    def index(self):

                .options(joinedload(UserLog.repository))

        #FILTERING

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

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

            .order_by(Gist.created_on.desc())

        # MY private

        if c.show_private and not c.show_public:

                             .filter(Gist.gist_owner == c.authuser.user_id)

        # MY public

        elif c.show_public and not c.show_private:

                             .filter(Gist.gist_owner == c.authuser.user_id)

        # MY public+private

        elif c.show_private and c.show_public:

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

                             .filter(Gist.gist_owner == c.authuser.user_id)

        # default show ALL public gists

                              self.authuser.user_id).all()]

        else:

            admin = True

                         .filter(Repository.user_id ==

                         .order_by(func.lower(Repository.repo_name)).all()

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

        c.active = 'emails'

        self.__load_data()

            .filter(UserEmailMap.user == c.user).all()

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

                    for un in no.notifications_to_users)

        repo_admin = h.HasRepoPermissionAny('repository.admin')

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

                            .get_user_notification(c.user.user_id, no)

            # if this association to user is not valid, we don't want to show

    def permission_ips(self):

        c.active = 'ips'

        c.user = User.get_default_user()

                        .filter(UserIpMap.user == c.user).all()

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

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

        """GET /repo_groups: All items in the collection"""

        # url('repos_groups')

                    .all()

        group_iter = RepoGroupList(_list, perm_set=['group.admin'])

        repo_groups_data = []

        #overwrite our cached list with current filter

        c.repo_cnt = 0

            .filter(RepoGroup.group_parent_id == c.group.group_id).all()

        c.groups = self.scm_model.get_repo_groups(groups)

                        .all()

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

from kallithea.lib.utils import action_logger, jsonify

from kallithea.lib.vcs import RepositoryError

from kallithea.model.meta import Session

    Setting, RepositoryField

from kallithea.model.forms import RepoForm, RepoFieldForm, RepoPermsForm

from kallithea.model.scm import ScmModel, AvailableRepoGroupChoices, RepoList

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

        """GET /repos: All items in the collection"""

        # url('repos')

                        .all()

        c.repos_list = RepoList(_list, perm_set=['repository.admin'])

        try:

            # CanWriteGroup validators checks permissions of this POST

            form_result = RepoForm(repo_groups=c.repo_groups,

                            .to_python(dict(request.POST))

            # create is done sometimes async on celery, db transaction

        c.repo_info = self._load_repo(repo_name)

        self.__load_defaults(c.repo_info)

        c.active = 'settings'

            .filter(RepositoryField.repository == c.repo_info).all()

        repo_model = RepoModel()

        """GET /repo_name/settings: Form to edit an existing item"""

        # url('edit_repo', repo_name=ID)

        defaults = self.__load_data(repo_name)

            .filter(RepositoryField.repository == c.repo_info).all()

        repo_model = RepoModel()

        c.users_array = repo_model.get_users_js()

        """GET /repo_name/settings: Form to edit an existing item"""

        # url('edit_repo', repo_name=ID)

        c.repo_info = self._load_repo(repo_name)

            .filter(RepositoryField.repository == c.repo_info).all()

        c.active = 'fields'

        if request.POST:

        # url('edit_repo', repo_name=ID)

        c.repo_info = self._load_repo(repo_name)

        c.default_user_id = User.get_default_user().user_id

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

        _repos = Repository.query().order_by(Repository.repo_name).all()

                h.flash(_('Please enter email address'), category='error')

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

                .get_email_tmpl(EmailNotificationModel.TYPE_DEFAULT,

                                'txt', body=test_body)

                .get_email_tmpl(EmailNotificationModel.TYPE_DEFAULT,

                                'html', body=test_body)

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

        """GET /users_groups: All items in the collection"""

        # url('users_groups')

                        .all()

        group_iter = UserGroupList(_list, perm_set=['usergroup.admin'])

        user_groups_data = []

            'repositories': {},

            'repositories_groups': {}

        }

            .all()

        for gr in ugroup_repo_perms:

            permissions['repositories'][gr.repository.repo_name]  \

                = gr.permission.permission_name

            .all()

        for gr in ugroup_group_perms:

            Session().add(user_group)

            usergroup_model = UserGroupModel()

                .all()

            for ug in defs:

                Session().delete(ug)

        """GET /users: All items in the collection"""

        # url('users')

                        .all()

        users_data = []

            Session().add(user)

            user_model = UserModel()

                .all()

            for ug in defs:

                Session().delete(ug)

    def edit_emails(self, id):

        c.user = self._get_user_or_raise_if_default(id)

        c.active = 'emails'

            .filter(UserEmailMap.user == c.user).all()

        defaults = c.user.get_dict()

    def edit_ips(self, id):

        c.user = self._get_user_or_raise_if_default(id)

        c.active = 'ips'

            .filter(UserIpMap.user == c.user).all()

        c.inherit_default_ips = c.user.inherit_default_permissions

            .filter(UserIpMap.user == User.get_default_user()).all()

        defaults = c.user.get_dict()

            user_id = get_user_or_error(userid).user_id

        gists = []

            .order_by(Gist.created_on.desc())

        for gist in _gists:

            gists.append(gist.get_api_data())

from kallithea.lib.helpers import RepoPage

from kallithea.lib.compat import json

from kallithea.lib.graphmod import graph_data

    ChangesetError, NodeDoesNotExistError, EmptyRepositoryError

from kallithea.lib.utils2 import safe_int, safe_str

from kallithea.lib.compat import json

import kallithea.lib.helpers as h

    NotAnonymous

from kallithea.lib.base import BaseRepoController, render

from kallithea.lib.utils import action_logger

                                              changeset.raw_id, with_revisions=True)

                                if st.changeset_comment_id is not None)

                            .get_inline_comments(c.db_repo.repo_id,

                                                 revision=changeset.raw_id)

                c.inline_comments.extend(inlines)

from kallithea.lib import helpers as h

from kallithea.lib.compat import OrderedDict

    str2bool

from kallithea.lib.auth import LoginRequired, HasRepoPermissionAnyDecorator

from kallithea.lib.base import BaseRepoController, render

from kallithea.lib.vcs.conf import settings

from kallithea.lib.vcs.exceptions import RepositoryError, \

    ChangesetDoesNotExistError, EmptyRepositoryError, \

    NodeDoesNotExistError, ChangesetError, NodeError

from kallithea.lib.vcs.nodes import FileNode

from kallithea.model.scm import ScmModel

from kallithea.model.db import Repository

    _context_url, get_line_ctx, get_ignore_ws

from webob.exc import HTTPNotFound

from kallithea.lib.exceptions import NonRelativePathError

    def followers(self, repo_name):

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

        repo_id = c.db_repo.repo_id

            .order_by(UserFollowing.follows_from)

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

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

        c.default_user_id = User.get_default_user().user_id

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

        if c.repo_info.stats:

        c.groups = self.scm_model.get_repo_groups()

        c.group = None

                        .all()

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

        if not repo_ids and user_ids:

            filtering_criterion = UserLog.user_id.in_(user_ids)

        if filtering_criterion is not None:

                .options(joinedload(UserLog.repository))

            #filter

            journal = _journal_filter(journal, c.search_term)

                        .order_by(UserLog.action_date.desc())

        else:

            journal = []

        # Return a rendered template

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

        c.user = User.get(self.authuser.user_id)

            .all()

        journal = self._get_journal_data(c.following)

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

            return render('journal/journal_data.html')

                     .filter(Repository.user_id ==

                     .order_by(func.lower(Repository.repo_name)).all()

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

        """

        Produce an atom-1.0 feed via feedgenerator module

        """

            .all()

        return self._atom_feed(following, public=False)

        """

        Produce an rss feed via feedgenerator module

        """

            .all()

        return self._rss_feed(following, public=False)

        # Return a rendered template

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

            .all()

        journal = self._get_journal_data(c.following)

        """

        Produce an atom-1.0 feed via feedgenerator module

        """

            .all()

        return self._atom_feed(c.following)

        """

        Produce an rss2 feed via feedgenerator module

        """

            .all()

        return self._rss_feed(c.following)

    @HasPermissionAnyDecorator('hg.admin', 'hg.register.auto_activate',

                               'hg.register.manual_activate')

    def register(self):

            .AuthUser.permissions['global']

        settings = Setting.get_app_settings()

from kallithea.lib.vcs.utils.hgcompat import unionrepo

from kallithea.lib.compat import json

from kallithea.lib.base import BaseRepoController, render

    NotAnonymous

from kallithea.lib.helpers import Page

from kallithea.lib import helpers as h

from kallithea.lib.vcs.utils import safe_str

from kallithea.lib.vcs.exceptions import EmptyRepositoryError

from kallithea.lib.diffs import LimitedDiffContainer

    PullRequestReviewers, User

from kallithea.model.pull_request import PullRequestModel

from kallithea.model.meta import Session

                s = filter(lambda p: p.status != PullRequest.STATUS_CLOSED, s)

            return s

                                .filter(PullRequest.user_id ==

                                .all())

                                .filter(PullRequestReviewers.user_id ==

                                                 )

        return render('/pullrequests/pullrequest_show_my.html')

from kallithea.model.db import Statistics, CacheInvalidation, User

from kallithea.lib.utils import jsonify

from kallithea.lib.utils2 import safe_str

    NotAnonymous

from kallithea.lib.base import BaseRepoController, render

from kallithea.lib.vcs.backends.base import EmptyChangeset

        else:

            c.show_stats = False

            .scalar()

        c.stats_percentage = 0

        c.ts_min = ts_min_m

        c.ts_max = ts_max_y

            .scalar()

        c.stats_percentage = 0

        if stats and stats.languages:

                sorted(lang_stats, reverse=True, key=lambda k: k[1])[:10]

            )

            last_rev = stats.stat_on_revision + 1

                if c.db_repo_scm_instance.revisions else 0

            if last_rev == 0 or c.repo_last_rev == 0:

                pass

        following function as ``annotate_from_changeset_func``::

            def changeset_to_anchor(changeset):

                       (changeset.id, changeset.id)

        :param annotate_from_changeset_func: see above

    #==================================================================

    # default global permissions taken from the default user

        .options(joinedload(UserToPerm.permission))

    for perm in default_global_perms:

    # USER GROUPS comes first

    # user group global permissions

        .join((UserGroupMember, UserGroupToPerm.users_group_id ==

        .join((UserGroup, UserGroupMember.users_group_id ==

        .all()

    # need to group here by groups since user can be in more than

    # one group

        if not gr.inherit_default_permissions:

            # NEED TO IGNORE all configurable permissions and

            # replace them with explicitly set

                                            .difference(_configurable)

        for perm in perms:

            permissions[GLOBAL].add(perm.permission.permission_name)

    # user specific global permissions

            .filter(UserToPerm.user_id == user_id).all()

    if not user_inherit_default_permissions:

        # NEED TO IGNORE all configurable permissions and

        # replace them with explicitly set

                                        .difference(_configurable)

        for perm in user_perms:

    # user group for repositories permissions

    user_repo_perms_from_users_groups = \

        .join((Repository, UserGroupRepoToPerm.repository_id ==

        .join((Permission, UserGroupRepoToPerm.permission_id ==

        .join((UserGroup, UserGroupRepoToPerm.users_group_id ==

        .join((UserGroupMember, UserGroupRepoToPerm.users_group_id ==

        .all()

    multiple_counter = collections.defaultdict(int)

    #======================================================================

    # user group for repo groups permissions

    user_repo_group_perms_from_users_groups = \

     .join((Permission, UserGroupRepoGroupToPerm.permission_id

     .join((UserGroup, UserGroupRepoGroupToPerm.users_group_id ==

     .join((UserGroupMember, UserGroupRepoGroupToPerm.users_group_id

     .all()

    multiple_counter = collections.defaultdict(int)

    #======================================================================

    # user group for user group permissions

    user_group_user_groups_perms = \

     .join((UserGroup, UserGroupUserGroupToPerm.target_user_group_id

     .join((Permission, UserGroupUserGroupToPerm.permission_id

     .join((UserGroupMember, UserGroupUserGroupToPerm.user_group_id

     .join((UserGroup, UserGroupMember.users_group_id ==

     .all()

    multiple_counter = collections.defaultdict(int)

    def _get_api_keys(self):

        api_keys = [self.api_key]

                .filter(or_(UserApiKeys.expires == -1,

                            UserApiKeys.expires >= time.time())).all():

            api_keys.append(api_key.api_key)

            return False