from rhodecode.lib.auth import LoginRequired, HasPermissionAllDecorator

from rhodecode.lib.exceptions import LdapImportError

from rhodecode.model.forms import LdapSettingsForm

log = logging.getLogger(__name__)

        super(LdapSettingsController, self).__before__()

    def index(self):

        c.search_scope_cur = defaults.get('ldap_search_scope')

        c.tls_reqcert_cur = defaults.get('ldap_tls_reqcert')

        c.tls_kind_cur = defaults.get('ldap_tls_kind')

                for k, v in form_result.items():

                    if k.startswith('ldap_'):

                        setting.app_settings_value = v

                        self.sa.add(setting)

from rhodecode.lib.base import BaseController, render

from rhodecode.lib.utils import invalidate_cache, action_logger, repo_name_slug

from rhodecode.lib.helpers import get_token

from rhodecode.model.forms import RepoForm

from rhodecode.model.scm import ScmModel

from rhodecode.model.repo import RepoModel

        super(ReposController, self).__before__()

    def __load_defaults(self):

        c.repo_groups_choices = map(lambda k: unicode(k[0]), c.repo_groups)

        repo_model = RepoModel()

from rhodecode.lib import helpers as h

from rhodecode.lib.auth import LoginRequired, HasPermissionAnyDecorator

from rhodecode.lib.base import BaseController, render

from rhodecode.model.repos_group import ReposGroupModel

from rhodecode.model.forms import ReposGroupForm

        super(ReposGroupsController, self).__before__()

    def __load_defaults(self):

        c.repo_groups_choices = map(lambda k: unicode(k[0]), c.repo_groups)

    def __load_data(self, group_id):

        """

        self.__load_defaults()

        data = repo_group.get_dict()

        # url('repos_groups')

        sk = lambda g:g.parents[0].group_name if g.parents else g.group_name

        return render('admin/repos_groups/repos_groups_show.html')

    @HasPermissionAnyDecorator('hg.admin')

        # url('repos_group', id=ID)

        self.__load_defaults()

        repos_group_model = ReposGroupModel()

        repos_group_form = ReposGroupForm(edit=True,

        # url('repos_group', id=ID)

        repos_group_model = ReposGroupModel()

        repos = gr.repositories.all()

        if repos:

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

        return redirect(url('repos_groups'))

    def show_by_name(self, group_name):

        return self.show(id_)

    def show(self, id, format='html'):

        """GET /repos_groups/id: Show a specific item"""

        # url('repos_group', id=ID)

        if c.group:

            c.group_repos = c.group.repositories.all()

        c.repo_cnt = 0

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

        id_ = int(id)

        defaults = self.__load_data(id_)

        # we need to exclude this group from the group list for editing

from rhodecode.lib.celerylib import tasks, run_task

from rhodecode.lib.utils import repo2db_mapper, invalidate_cache, \

    set_rhodecode_config, repo_name_slug

from rhodecode.model.forms import UserForm, ApplicationSettingsForm, \

    ApplicationUiSettingsForm

from rhodecode.model.scm import ScmModel

        """GET /admin/settings: All items in the collection"""

        # url('admin_settings')

        defaults.update(self.get_hg_ui_settings())

        return htmlfill.render(

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

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

                try:

                    hgsettings1.app_settings_value = \

                        form_result['rhodecode_title']

                    hgsettings2.app_settings_value = \

                        form_result['rhodecode_realm']

                    hgsettings3.app_settings_value = \

                        form_result['rhodecode_ga_code']

    def create_repository(self):

        """GET /_admin/create_repository: Form to create a new item"""

        c.repo_groups_choices = map(lambda k: unicode(k[0]), c.repo_groups)

        new_repo = request.GET.get('repo', '')

from rhodecode.lib.auth import LoginRequired, HasPermissionAllDecorator

from rhodecode.lib.base import BaseController, render

from rhodecode.model.forms import UserForm

from rhodecode.model.user import UserModel

    HasPermissionAnyDecorator

from rhodecode.model.scm import ScmModel

from rhodecode.model.repo import RepoModel

from rhodecode.model.user import UserModel

from rhodecode.model.repo_permission import RepositoryPermissionModel

            groups = groups[:-1]

            parent_id = None

            for g in groups:

                if not group:

                    group = ReposGroupModel().create(dict(group_name=g,

                                                  group_description='',

from rhodecode.lib.auth import LoginRequired

from rhodecode.lib.base import BaseController, render

log = logging.getLogger(__name__)

        c.repos_list = self.scm_model.get_repos()

        return render('/index.html')

from rhodecode.model.forms import RepoSettingsForm, RepoForkForm

from rhodecode.model.repo import RepoModel

log = logging.getLogger(__name__)

        super(SettingsController, self).__before__()

    def __load_defaults(self):

        c.repo_groups_choices = map(lambda k: unicode(k[0]), c.repo_groups)

        repo_model = RepoModel()

from rhodecode.model import meta

from rhodecode.model.user import UserModel

log = logging.getLogger(__name__)

            log.debug('this user already exists as non ldap')

            return False

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

        # FALLBACK TO LDAP AUTH IF ENABLE

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

from rhodecode.lib.utils import ask_ok

from rhodecode.model import init_model

from rhodecode.model.db import User, Permission, RhodeCodeUi, \

from sqlalchemy.engine import create_engine

        """Fixes rhodecode settings adds ga_code key for google analytics

        """

        try:

            self.sa.add(hgsettings3)

                        ('ldap_attr_login', ''), ('ldap_attr_firstname', ''),

                        ('ldap_attr_lastname', ''), ('ldap_attr_email', '')]:

                    log.debug('Skipping option %s' % k)

                    continue

                self.sa.add(setting)

            self.sa.commit()

        except:

        paths.ui_key = '/'

        paths.ui_value = path

        try:

            self.sa.add(web1)

from rhodecode.model import meta

from rhodecode.model.caching_query import FromCache

from rhodecode.model.repo import RepoModel

log = logging.getLogger(__name__)

    :param config:

    """

    for k, v in hgsettings.items():

        config[k] = v

    for lvl, group_name in enumerate(groups):

        group_name = '/'.join(groups[:lvl] + [group_name])

        if group is None:

            sa.add(group)

            sa.commit()

        parent = group

    added = []

    # fixup groups paths to new format on the fly

    # TODO: remove this in future

        g.group_name = g.get_new_name(g.name)

        sa.add(g)    

    for name, repo in initial_repo_list.items():

        Session.commit()

    __tablename__ = 'rhodecode_settings'

    __table_args__ = (UniqueConstraint('app_settings_name'), {'extend_existing':True})

    app_settings_id = Column("app_settings_id", Integer(), nullable=False, unique=True, default=None, primary_key=True)

    repositories = relationship('Repository')

    user_followers = relationship('UserFollowing', primaryjoin='UserFollowing.follows_user_id==User.user_id', cascade='all')

    group_member = relationship('UsersGroupMember', cascade='all')

                        users_group_id).all()

            if assigned_groups:

                                                   assigned_groups)

            users_group = cls.get(users_group_id, cache=False)

    user = relationship('User')

    fork = relationship('Repository', remote_side=repo_id)

    users_group_to_perm = relationship('UsersGroupRepoToPerm', cascade='all')

    stats = relationship('Statistics', cascade='all', uselist=False)

        return repo

    __tablename__ = 'groups'

    __table_args__ = (UniqueConstraint('group_name', 'group_parent_id'),

                      CheckConstraint('group_id != group_parent_id'), {'extend_existing':True},)

    group_parent_id = Column("group_parent_id", Integer(), ForeignKey('groups.group_id'), nullable=True, unique=None, default=None)

    group_description = Column("group_description", String(length=10000, convert_unicode=False, assert_unicode=None), nullable=True, unique=None, default=None)

    def __init__(self, group_name='', parent_group=None):

    @property

    def children(self):

    @property

    def name(self):

    @property

    def full_path(self):

    @property

    def full_path_splitted(self):

    @property

    def repositories(self):

        """

        path_prefix = (self.parent_group.full_path_splitted if

                       self.parent_group else [])

class Permission(Base, BaseModel):

    def get_by_key(cls, key):

        return cls.query().filter(cls.permission_name == key).scalar()

    __tablename__ = 'repo_to_perm'

    __table_args__ = (UniqueConstraint('user_id', 'repository_id'), {'extend_existing':True})

    repo_to_perm_id = Column("repo_to_perm_id", Integer(), nullable=False, unique=True, default=None, primary_key=True)

            Session.rollback()

    __tablename__ = 'group_to_perm'

    __table_args__ = (UniqueConstraint('group_id', 'permission_id'), {'extend_existing':True})

    user = relationship('User')

    permission = relationship('Permission')

class Statistics(Base, BaseModel):

    __tablename__ = 'statistics'

from rhodecode.lib.exceptions import LdapImportError

from rhodecode.model.user import UserModel

from rhodecode.model.repo import RepoModel

from rhodecode import BACKENDS

log = logging.getLogger(__name__)

            if re.match(r'^[a-zA-Z0-9]{1}[a-zA-Z0-9\-\_\.]+$', value) is None:

                                           'alphanumeric characters '

                                           'underscores, periods or dashes '

                                           'and must begin with alphanumeric '

            old_gname = None

            if edit:

                            old_data.get('group_id')).group_name

            if old_gname != group_name or not edit:

                # check filesystem

                if gr:

                    e_dict = {'group_name':_('This group already exists')}

            if value.get('repo_group'):

                group_path = gr.full_path

                # value needs to be aware of group name in order to check

                # db key This is an actual just the name to store in the

                # database

            else:

                group_path = ''

                                  gr.group_name}

                        raise formencode.Invalid('', value, state,

                                                 error_dict=e_dict)

                        e_dict = {'repo_name':_('There is a group with this'

                                                ' name already "%s"') %

                                  repo_name_full}

from sqlalchemy.exc import DatabaseError

from rhodecode.model import BaseModel

from rhodecode.model.caching_query import FromCache

log = logging.getLogger(__name__)

            #stage 2 update all default permissions for repos if checked

            if form_result['overwrite_default'] == True:

                    r2p.permission = self.get_permission_by_name(

                                         form_result['default_perm'])

                    self.sa.add(r2p)

from rhodecode.model import BaseModel

from rhodecode.model.caching_query import FromCache

from rhodecode.model.user import UserModel

log = logging.getLogger(__name__)

            # update permissions

            for member, perm, member_type in form_data['perms_updates']:

                if member_type == 'user':

                            .one()

                    r2p.permission = self.sa.query(Permission)\

            # set new permissions

            for member, perm, member_type in form_data['perms_new']:

                if member_type == 'user':

                    r2p.repository = cur_repo

                    r2p.user = User.get_by_username(member)

                elif k == 'repo_name':

                    pass

                elif k == 'repo_group':

                else:

                    setattr(cur_repo, k, v)

            self.sa.add(new_repo)

            #create default permission

            default = 'repository.read'

            for p in User.get_by_username('default').user_perms:

                if p.permission.permission_name.startswith('repository.'):

    def delete_perm_user(self, form_data, repo_name):

        try:

                        == self.get_by_repo_name(repo_name))\

            self.sa.commit()

        except:

            log.error(traceback.format_exc())

        from rhodecode.lib.utils import is_valid_repo, is_valid_repos_group

        if new_parent_id:

            new_parent_path = os.sep.join(paths)

        else:

            new_parent_path = ''

# along with this program.  If not, see <http://www.gnu.org/licenses/>.

import logging

from rhodecode.model.meta import Session

log = logging.getLogger(__name__)

class RepositoryPermissionModel(BaseModel):

    def get_user_permission(self, repository, user):

                .scalar()

    def update_user_permission(self, repository, user, permission):

            if not current.permission is permission:

                current.permission = permission

        else:

            p.user = user

            p.repository = repository

            p.permission = permission

from vcs.utils.lazy import LazyProperty

from rhodecode.model import BaseModel

log = logging.getLogger(__name__)

        :param group: instance of group from database

        """

        paths = os.sep.join(paths)

        rm_path = os.path.join(self.repos_path, paths)

    def create(self, form_data):

        try:

            new_repos_group.group_description = form_data['group_description']

            new_repos_group.group_name = new_repos_group.get_new_name(form_data['group_name'])

            self.sa.add(new_repos_group)

    def update(self, repos_group_id, form_data):

        try:

            old_path = repos_group.full_path

            # change properties

            repos_group.group_description = form_data['group_description']

            repos_group.group_name = repos_group.get_new_name(form_data['group_name'])

            new_path = repos_group.full_path

    def delete(self, users_group_id):

        try:

            self.sa.delete(users_group)

            self.__delete_group(users_group)

            self.sa.commit()

from rhodecode.lib import safe_unicode

from rhodecode.model import BaseModel

from rhodecode.model.caching_query import FromCache

    UserToPerm, UsersGroupRepoToPerm, UsersGroupToPerm, UsersGroupMember

from rhodecode.lib.exceptions import DefaultUserException, \

    UserOwnsReposException

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

        default_user = self.get_by_username('default', cache=True)

                   Repository.repo_id))\

                   Permission.permission_id))\

        if user.is_admin:

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

            for perm in default_perms:

                p = 'repository.admin'

                                                 repository.repo_name] = p

        else:

                else:

                    p = perm.Permission.permission_name

                                                 repository.repo_name] = p

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

                                               permission_name)

            #user repositories

                                            Repository)\

                       Repository.repo_id))\

                       Permission.permission_id))\

            for perm in user_repo_perms:

                # set admin if owner

                    p = 'repository.admin'

                else:

                    p = perm.Permission.permission_name

                                                 repository.repo_name] = p

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

                    <tr>

                        <th class="left"><a href="#">${_('Group name')}</a></th>

                        <th class="left"><a href="#">${_('Description')}</a></th>

                        <th class="left">${_('action')}</th>

                    </tr>

                </thead>

from rhodecode.tests import *

from nose.plugins.skip import SkipTest

skip_ldap_test = False

                    'ldap_attr_lastname':'tester',

                    'ldap_attr_email':'test@example.com' })