from alembic import op

from sqlalchemy import MetaData, Table

meta = MetaData()

def upgrade():

    meta.bind = op.get_bind()

    ui.update(values={

        'ui_key': 'prechangegroup.push_lock_handling',

def downgrade():

    meta.bind = op.get_bind()

    ui.update(values={

        'ui_key': 'prechangegroup.pre_push',

from alembic import op

from sqlalchemy import MetaData, Table

meta = MetaData()

        batch_op.drop_column('enable_locking')

    meta.bind = op.get_bind()

    ui.delete().where(ui.c.ui_key == 'prechangegroup.push_lock_handling').execute()

    ui.delete().where(ui.c.ui_key == 'preoutgoing.pull_lock_handling').execute()

import sqlalchemy as sa

from alembic import op

def upgrade():

    # duplicate_values contains one copy of each duplicated pair

    duplicate_values = (

        session

    )

    for pull_request_id, user_id in duplicate_values:

        # currently being processed

        duplicate_occurrences = (

            session

        )

        for prr in duplicate_occurrences:

            if (pull_request_id, user_id) in seen:

import kallithea.bin.kallithea_cli_base as cli_base

from kallithea.lib.utils import REMOVED_REPO_PAT, repo2db_mapper

from kallithea.lib.utils2 import ask_ok

from kallithea.model.scm import ScmModel

    updated.

    """

    if not repositories:

    else:

        repo_names = [n.strip() for n in repositories]

    for repo in repo_list:

        # update latest revision metadata in database

from kallithea.lib.base import BaseVCSController, get_path_info

from kallithea.lib.hooks import log_pull_action

from kallithea.lib.utils import make_ui

log = logging.getLogger(__name__)

                parsed_request.service == 'git-upload-pack'

            ):

                baseui = make_ui()

                scm_repo = repo.scm_instance

                # Run hooks, like Mercurial outgoing.pull_logger does

                log_pull_action(ui=baseui, repo=scm_repo._repo)

from kallithea.lib.indexers import JOURNAL_SCHEMA

from kallithea.lib.page import Page

from kallithea.lib.utils2 import remove_prefix, remove_suffix, safe_int

log = logging.getLogger(__name__)

    def get_filterion(field, val, term):

        if field == 'repository':

        elif field == 'ip':

        elif field == 'date':

        elif field == 'username':

        else:

        log.debug('filter field: %s val=>%s', field, val)

        # sql filtering

    @HasPermissionAnyDecorator('hg.admin')

    def index(self):

        # FILTERING

        c.search_term = request.GET.get('filter')

        users_log = _journal_filter(users_log, c.search_term)

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

from kallithea.lib import helpers as h

from kallithea.lib.auth import HasPermissionAnyDecorator, LoginRequired

from kallithea.lib.base import BaseController, render

from kallithea.model.forms import AuthSettingsForm

                if "default" in v:

                    c.defaults[fullname] = v["default"]

                # Current values will be the default on the form, if there are any

                if setting is not None:

                    c.defaults[fullname] = setting.app_settings_value

        if defaults:

                    # we want to store it comma separated inside our settings

                    v = ','.join(v)

                log.debug("%s = %s", k, str(v))

            meta.Session().commit()

            h.flash(_('Auth settings updated successfully'),

                       category='success')

from kallithea.lib import helpers as h

from kallithea.lib.auth import HasPermissionAnyDecorator, LoginRequired

from kallithea.lib.base import BaseController, render

from kallithea.model.forms import DefaultsForm

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

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

        return htmlfill.render(

            render('admin/defaults/defaults.html'),

        try:

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

            for k, v in form_result.items():

            meta.Session().commit()

            h.flash(_('Default settings updated successfully'),

                    category='success')

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

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

from kallithea.lib.webutils import url

from kallithea.model.forms import GistForm

from kallithea.model.gist import GistModel

        elif c.show_private:

            url_params['private'] = 1

            .filter_by(is_expired=False) \

        # MY private

        if c.show_private and not c.show_public:

        # MY public

        elif c.show_public and not c.show_private:

        # MY public+private

        elif c.show_private and c.show_public:

        # default show ALL public gists

        if not c.show_public and not c.show_private:

        c.gists = gists

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

        try:

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

            # TODO: multiple files support, from the form

            nodes = {

                filename: {

                    'content': form_result['content'],

                }

            }

            _public = form_result['public']

            gist = GistModel().create(

                description=form_result['description'],

                owner=request.authuser.user_id,

    @LoginRequired(allow_default_user=True)

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

        if c.gist.is_expired:

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

    @LoginRequired()

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

        if c.gist.is_expired:

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

    @LoginRequired()

    @jsonify

    def check_revision(self, gist_id):

        last_rev = c.gist.scm_instance.get_changeset()

        success = True

        revision = request.POST.get('revision')

from kallithea.lib.auth import AuthUser, LoginRequired

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

from kallithea.lib.utils2 import generate_api_key, safe_int

from kallithea.model.api_key import ApiKeyModel

from kallithea.model.forms import PasswordChangeForm, UserForm

from kallithea.model.repo import RepoModel

from kallithea.model.ssh_key import SshKeyModel, SshKeyModelException

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

    def __load_data(self):

        if c.user.is_default_user:

            h.flash(_("You can't edit this user since it's"

                      " crucial for entire application"), category='warning')

    def _load_my_repos_data(self, watched=False):

        if watched:

            admin = False

                                 request.authuser.user_id).all()

        else:

            admin = True

                                 request.authuser.user_id).all()

        return RepoModel().get_repos_as_dict(repos_list, admin=admin)

        self.__load_data()

        c.perm_user = AuthUser(user_id=request.authuser.user_id)

        managed_fields = auth_modules.get_managed_fields(c.user)

        if 'hg.register.none' in def_user_perms:

            managed_fields.extend(['username', 'firstname', 'lastname', 'email'])

        c.active = 'emails'

        self.__load_data()

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

    def my_account_emails_add(self):

    def my_account_api_keys_delete(self):

        api_key = request.POST.get('del_api_key')

        if request.POST.get('del_api_key_builtin'):

            user.api_key = generate_api_key()

            meta.Session().commit()

            h.flash(_("API key successfully reset"), category='success')

from kallithea.lib import helpers as h

from kallithea.lib.auth import AuthUser, HasPermissionAnyDecorator, LoginRequired

from kallithea.lib.base import BaseController, render

from kallithea.model.forms import DefaultPermissionsForm

from kallithea.model.permission import PermissionModel

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

        defaults = {'anonymous': c.user.active}

        for p in c.user.user_perms:

    def permission_ips(self):

        c.active = 'ips'

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

    def permission_perms(self):

        c.active = 'perms'

        c.perm_user = AuthUser(dbuser=c.user)

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

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

from kallithea.lib.base import BaseController, render

from kallithea.lib.utils2 import safe_int

from kallithea.model.forms import RepoGroupForm, RepoGroupPermsForm

from kallithea.model.repo import RepoModel

from kallithea.model.repo_group import RepoGroupModel

        :param group_id:

        """

        data = repo_group.get_dict()

        data['group_name'] = repo_group.name

        return False

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

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

        repo_groups_data = []

        _tmpl_lookup = app_globals.mako_lookup

            # 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_name = group.group_name if group else None

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

                pass

    @HasRepoGroupPermissionLevelDecorator('admin')

    def update(self, group_name):

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

                             exclude=[c.repo_group])

    @HasRepoGroupPermissionLevelDecorator('admin')

    def delete(self, group_name):

        repos = gr.repositories.all()

        if repos:

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

        the group by id view instead

        """

        group_name = group_name.rstrip('/')

        if id_:

            return self.show(group_name)

        raise HTTPNotFound

    def show(self, group_name):

        c.active = 'settings'

        repo_groups_list = self.scm_model.get_repo_groups(groups)

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

                                               repo_groups_list=repo_groups_list,

                                               short_name=True)

    def edit(self, group_name):

        c.active = 'settings'

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

                             exclude=[c.repo_group])

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

    @HasRepoGroupPermissionLevelDecorator('admin')

    def edit_repo_group_advanced(self, group_name):

        c.active = 'advanced'

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

    @HasRepoGroupPermissionLevelDecorator('admin')

    def edit_repo_group_perms(self, group_name):

        c.active = 'perms'

        self.__load_defaults()

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

        :param group_name:

        """

        valid_recursive_choices = ['none', 'repos', 'groups', 'all']

        form_result = RepoGroupPermsForm(valid_recursive_choices)().to_python(request.POST)

        if not request.authuser.is_admin:

from kallithea.lib.utils2 import safe_int

from kallithea.lib.vcs import RepositoryError

from kallithea.lib.webutils import url

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

from kallithea.model.repo import RepoModel

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

        return defaults

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

        # the repo list will be filtered to only show repos where the user has read permissions

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

        # data used to render the grid

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

        ## apply the defaults from defaults page

        if parent_group:

            if prg is None or not any(rgc[0] == prg.group_id

                                      for rgc in c.repo_groups):

                raise HTTPForbidden

                if task_result.failed():

                    raise HTTPInternalServerError(task_result.traceback)

            if repo.clone_uri:

                h.flash(_('Created repository %s from %s')

                        % (repo.repo_name, repo.clone_uri_hidden), category='success')

        c.repo_info = self._load_repo()

        self.__load_defaults(c.repo_info)

        c.active = 'settings'

        repo_model = RepoModel()

        changed_name = repo_name

        old_data = {

            'repo_name': repo_name,

            'repo_group': repo.group.get_dict() if repo.group else {},

    @HasRepoPermissionLevelDecorator('admin')

    def edit(self, repo_name):

        defaults = self.__load_data()

        c.active = 'settings'

        return htmlfill.render(

            render('admin/repos/repo_edit.html'),

    @HasRepoPermissionLevelDecorator('admin')

    def edit_fields(self, repo_name):

        c.repo_info = self._load_repo()

        c.active = 'fields'

        if request.POST:

    def create_repo_field(self, repo_name):

        try:

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

            new_field.field_key = form_result['new_field_key']

            new_field.field_type = form_result['new_field_type']  # python type

            new_field.field_value = form_result['new_field_value']  # set initial blank value

    @HasRepoPermissionLevelDecorator('admin')

    def delete_repo_field(self, repo_name, field_id):

        try:

            meta.Session().delete(field)

            meta.Session().commit()

    def edit_advanced(self, repo_name):

        c.repo_info = self._load_repo()

        c.default_user_id = kallithea.DEFAULT_USER_ID

        read_access_repos = RepoList(_repos, perm_level='read')

        c.repos_list = [(None, _('-- Not a fork --'))]

        c.repos_list += [(x.repo_id, x.repo_name)

        """

        try:

            user_id = kallithea.DEFAULT_USER_ID

            self.scm_model.toggle_following_repo(repo_id, user_id)

            h.flash(_('Updated repository visibility in public journal'),

from kallithea.lib.utils2 import safe_str

from kallithea.lib.vcs import VCSError

from kallithea.lib.webutils import url

from kallithea.model.forms import ApplicationSettingsForm, ApplicationUiSettingsForm, ApplicationVisualisationForm

from kallithea.model.notification import EmailNotificationModel

from kallithea.model.scm import ScmModel

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

    def _get_hg_ui_settings(self):

        settings = {}

        for each in ret:

            try:

                if c.visual.allow_repo_location_change:

                    sett.ui_value = form_result['paths_root_path']

                # HOOKS

                sett.ui_active = form_result['hooks_changegroup_update']

                sett.ui_active = form_result['hooks_changegroup_repo_size']

                ## EXTENSIONS

                sett.ui_active = form_result['extensions_largefiles']

#                sett.ui_active = form_result['extensions_hggit']

                meta.Session().commit()

                h.flash(_('Error occurred while updating '

                          'application settings'), category='error')

        defaults.update(self._get_hg_ui_settings())

        return htmlfill.render(

            if invalidate_cache:

                log.debug('invalidating all repositories cache')

                i = 0

                    try:

                        ScmModel().mark_for_invalidation(repo.repo_name)

                        i += 1

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

        defaults.update(self._get_hg_ui_settings())

        return htmlfill.render(

                    'captcha_public_key',

                    'captcha_private_key',

                ):

                meta.Session().commit()

                set_app_settings(config)

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

        defaults.update(self._get_hg_ui_settings())