from rhodecode.lib import helpers as h

from rhodecode.lib.auth import LoginRequired, HasPermissionAllDecorator

from rhodecode.lib.base import BaseController, render

from rhodecode.model.forms import DefaultPermissionsForm

from rhodecode.model.permission import PermissionModel

from rhodecode.model.db import User

log = logging.getLogger(__name__)

class PermissionsController(BaseController):

    """REST Controller styled on the Atom Publishing Protocol"""

                                       [x[0] for x in self.create_choices])()

        try:

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

            form_result.update({'perm_user_name': id})

            permission_model.update(form_result)

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

                    category='success')

        except formencode.Invalid, errors:

            c.perms_choices = self.perms_choices

            c.register_choices = self.register_choices

from rhodecode.lib import helpers as h

from rhodecode.lib.auth import LoginRequired, HasPermissionAnyDecorator

from rhodecode.lib.base import BaseController, render

from rhodecode.model.db import RepoGroup

from rhodecode.model.repos_group import ReposGroupModel

from rhodecode.model.forms import ReposGroupForm

log = logging.getLogger(__name__)

class ReposGroupsController(BaseController):

    """REST Controller styled on the Atom Publishing Protocol"""

    @HasPermissionAnyDecorator('hg.admin')

    def create(self):

        """POST /repos_groups: Create a new item"""

        # url('repos_groups')

        self.__load_defaults()

        repos_group_form = ReposGroupForm(available_groups=

                                          c.repo_groups_choices)()

        try:

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

            h.flash(_('created repos group %s') \

                    % form_result['group_name'], category='success')

            #TODO: in futureaction_logger(, '', '', '', self.sa)

        except formencode.Invalid, errors:

            return htmlfill.render(

        #           method='put')

        # url('repos_group', id=ID)

        self.__load_defaults()

        c.repos_group = RepoGroup.get(id)

        repos_group_form = ReposGroupForm(edit=True,

                                          old_data=c.repos_group.get_dict(),

                                          available_groups=

                                            c.repo_groups_choices)()

        try:

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

            h.flash(_('updated repos group %s') \

                    % form_result['group_name'], category='success')

            #TODO: in futureaction_logger(, '', '', '', self.sa)

        except formencode.Invalid, errors:

            return htmlfill.render(

        #    <input type="hidden" name="_method" value="DELETE" />

        # Or using helpers:

        #    h.form(url('repos_group', id=ID),

        #           method='delete')

        # url('repos_group', id=ID)

        gr = RepoGroup.get(id)

        repos = gr.repositories.all()

        if repos:

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

                      'deleted' % len(repos)),

                    category='error')

            return redirect(url('repos_groups'))

        try:

            h.flash(_('removed repos group %s' % gr.group_name), category='success')

            #TODO: in future action_logger(, '', '', '', self.sa)

        except IntegrityError, e:

            if e.message.find('groups_group_parent_id_fkey'):

                log.error(traceback.format_exc())

                h.flash(_('Cannot delete this group it still contains '

import traceback

import logging

from rhodecode.controllers.api import JSONRPCController, JSONRPCError

from rhodecode.lib.auth import HasPermissionAllDecorator, \

    HasPermissionAnyDecorator

from rhodecode.model.scm import ScmModel

from rhodecode.model.db import User, UsersGroup, RepoGroup, Repository

from rhodecode.model.repo import RepoModel

from rhodecode.model.user import UserModel

from rhodecode.model.repo_permission import RepositoryPermissionModel

from rhodecode.model.users_group import UsersGroupModel

from rhodecode.model.repos_group import ReposGroupModel

log = logging.getLogger(__name__)

class ApiController(JSONRPCController):

    """

        if User.get_by_username(username):

            raise JSONRPCError("user %s already exist" % username)

        try:

            UserModel().create_or_update(username, password, email, firstname, 

                                         lastname, active, admin, ldap_dn)

            return dict(msg='created new user %s' % username)

        except Exception:

            log.error(traceback.format_exc())

            raise JSONRPCError('failed to create user %s' % username)

    @HasPermissionAllDecorator('hg.admin')

        """

        if self.get_users_group(apiuser, name):

            raise JSONRPCError("users group %s already exist" % name)

        try:

            return dict(id=ug.users_group_id,

                        msg='created new users group %s' % name)

        except Exception:

            log.error(traceback.format_exc())

            raise JSONRPCError('failed to create group %s' % name)

            try:

                user = User.get_by_username(user_name)

            except NoResultFound:

                raise JSONRPCError('unknown user %s' % user_name)

            ugm = UsersGroupModel().add_user_to_group(users_group, user)

            return dict(id=ugm.users_group_member_id,

                        msg='created new users group member')

        except Exception:

            log.error(traceback.format_exc())

            raise JSONRPCError('failed to create users group member')

                                     repo_name_full=name,

                                     description=description,

                                     private=private,

                                     repo_type=repo_type,

                                     repo_group=parent_id,

                                     clone_uri=None), owner)

        except Exception:

            log.error(traceback.format_exc())

            raise JSONRPCError('failed to create repository %s' % name)

    @HasPermissionAnyDecorator('hg.admin')

    def add_user_to_repo(self, apiuser, repo_name, user_name, perm):

                user = User.get_by_username(user_name)

            except NoResultFound:

                raise JSONRPCError('unknown user %s' % user)

            RepositoryPermissionModel()\

                .update_or_delete_user_permission(repo, user, perm)

        except Exception:

            log.error(traceback.format_exc())

            raise JSONRPCError('failed to edit permission %(repo)s for %(user)s'

                            % dict(user=user_name, repo=repo_name))

        checkfirst = not override

        meta.Base.metadata.create_all(checkfirst=checkfirst)

        log.info('Created tables for %s', self.dbname)

    def set_db_version(self):

            ver = DbMigrateVersion()

            ver.version = __dbversion__

            ver.repository_id = 'rhodecode_db_migrations'

            ver.repository_path = 'versions'

            self.sa.add(ver)

        log.info('db version set to: %s', __dbversion__)

    def upgrade(self):

        """Upgrades given database schema to given revision following

        all needed steps, to perform the upgrade

        dotencode_disable = RhodeCodeUi()

        dotencode_disable.ui_section = 'format'

        dotencode_disable.ui_key = 'dotencode'

        dotencode_disable.ui_value = 'false'

        # enable largefiles

            self.sa.add(hooks1)

            self.sa.add(hooks2)

            self.sa.add(hooks3)

            self.sa.add(hooks4)

    def create_ldap_options(self,skip_existing=False):

        """Creates ldap settings"""

            for k, v in [('ldap_active', 'false'), ('ldap_host', ''),

                        ('ldap_port', '389'), ('ldap_tls_kind', 'PLAIN'),

                        ('ldap_tls_reqcert', ''), ('ldap_dn_user', ''),

                        ('ldap_dn_pass', ''), ('ldap_base_dn', ''),

                        ('ldap_filter', ''), ('ldap_search_scope', ''),

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

                if skip_existing and RhodeCodeSetting.get_by_name(k) != None:

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

                    continue

                setting = RhodeCodeSetting(k, v)

                self.sa.add(setting)

    def config_prompt(self, test_repo_path='', retries=3):

        if retries == 3:

            log.info('Setting up repositories config')

        if not self.tests and not test_repo_path:

        paths.ui_value = path

        hgsettings1 = RhodeCodeSetting('realm', 'RhodeCode authentication')

        hgsettings2 = RhodeCodeSetting('title', 'RhodeCode')

        hgsettings3 = RhodeCodeSetting('ga_code', '')

            self.sa.add(web1)

            self.sa.add(web2)

            self.sa.add(web3)

            self.sa.add(web4)

            self.sa.add(paths)

            self.sa.add(hgsettings1)

            self.sa.add(hgsettings2)

            self.sa.add(hgsettings3)

        self.create_ldap_options()

        log.info('created ui config')

    def create_user(self, username, password, email='', admin=False):

        log.info('creating user %s', username)

                ]

        for p in perms:

            new_perm = Permission()

            new_perm.permission_name = p[0]

            new_perm.permission_longname = p[1]

                self.sa.add(new_perm)

    def populate_default_permissions(self):

        log.info('creating default user permissions')

        default_user = self.sa.query(User)\

        .filter(User.username == 'default').scalar()

        default_repo_perm = UserToPerm()

        default_repo_perm.user = default_user

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

        .filter(Permission.permission_name == 'repository.read')\

        .scalar()

            self.sa.add(reg_perm)

            self.sa.add(create_repo_perm)

            self.sa.add(default_repo_perm)

from rhodecode.lib.caching_query import FromCache

from rhodecode.model import meta

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

    UserLog, RepoGroup, RhodeCodeSetting

log = logging.getLogger(__name__)

def recursive_replace(str_, replace=' '):

    """Recursive replace of given sign to just one instance

    dbmanage.create_tables(override=True)

    dbmanage.create_settings(dbmanage.config_prompt(repos_test_path))

    dbmanage.create_default_user()

    dbmanage.admin_prompt()

    dbmanage.create_permissions()

    dbmanage.populate_default_permissions()

    # PART TWO make test repo

    log.debug('making test vcs repositories')

    idx_path = config['app_conf']['index_dir']

    data_path = config['app_conf']['cache_dir']

                subj = _('[Mention]') + ' ' + subj

                NotificationModel().create(created_by=user_id, subject=subj,

                                    body=body,

                                    recipients=mention_recipients,

                                    type_=Notification.TYPE_CHANGESET_COMMENT)

            return comment

    def delete(self, comment):

        """

        Deletes given comment

            # stage 3 set anonymous access

            if perm_user.username == 'default':

                perm_user.active = bool(form_result['anonymous'])

                self.sa.add(perm_user)

        except (DatabaseError,):

            log.error(traceback.format_exc())

            raise

        else:

            p = UserRepoToPerm()

            p.user = user

            p.repository = repository

            p.permission = permission

            self.sa.add(p)

    def delete_user_permission(self, repository, user):

        current = self.get_user_permission(repository, user)

        if current:

            self.sa.delete(current)

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

        if permission:

            self.update_user_permission(repository, user, permission)

        else:

            self.delete_user_permission(repository, user)

            new_repos_group = RepoGroup()

            new_repos_group.group_description = form_data['group_description']

            new_repos_group.parent_group = RepoGroup.get(form_data['group_parent_id'])

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

            self.sa.add(new_repos_group)

            self.__create_group(new_repos_group.group_name)

            return new_repos_group

        except:

            log.error(traceback.format_exc())

            raise

    def update(self, repos_group_id, form_data):

        try:

            repos_group = RepoGroup.get(repos_group_id)

            # we need to get all repositories from this new group and 

            # rename them accordingly to new group path

            for r in repos_group.repositories:

                r.repo_name = r.get_new_name(r.just_name)

                self.sa.add(r)

            return repos_group

        except:

            log.error(traceback.format_exc())

            raise

    def delete(self, users_group_id):

        try:

            users_group = RepoGroup.get(users_group_id)

            self.sa.delete(users_group)

            self.__delete_group(users_group)

        except:

            log.error(traceback.format_exc())

            raise

            new_user.api_key = generate_api_key(username)

            new_user.email = email

            new_user.active = active

            new_user.ldap_dn = safe_unicode(ldap_dn) if ldap_dn else None

            new_user.name = name

            new_user.lastname = lastname

            self.sa.add(new_user)

            return new_user

        except (DatabaseError,):

            log.error(traceback.format_exc())

            raise

    def create_for_container_auth(self, username, attrs):

        """

        Creates the given user if it's not already in the database

    def get(self, users_group_id, cache=False):

        return UsersGroup.get(users_group_id)

    def get_by_name(self, name, cache=False, case_insensitive=False):

        return UsersGroup.get_by_group_name(name, cache, case_insensitive)

        new = UsersGroup()

        new.users_group_name = name

        new.users_group_active = active

        self.sa.add(new)

        return new

            users_group_member.users_group = users_group

            users_group.members.append(users_group_member)

            user.group_member.append(users_group_member)

            self.sa.add(users_group_member)

            return users_group_member

        except:

            log.error(traceback.format_exc())

            raise

load_environment(conf.global_conf, conf.local_conf)

add_cache(conf)

USER = 'test_admin'

PASS = 'test12'

METHOD = 'pull'

DEBUG = True

log = logging.getLogger(__name__)

class Command(object):

            return gr

        form_data = dict(group_name=path,

                         group_description=desc,

                         group_parent_id=parent_id)

        gr = ReposGroupModel().create(form_data)

        return gr

    def __delete_group(self, id_):

        ReposGroupModel().delete(id_)

        self.assertTrue(self.__check_path('newGroup'))

    def test_create_same_name_group(self):

        self.assertRaises(IntegrityError, lambda:self.__make_group('newGroup'))

    def test_same_subgroup(self):

        sg1 = self.__make_group('sub1', parent_id=self.g1.group_id)

        self.assertEqual(sg1.parent_group, self.g1)

        self.assertEqual(sg1.full_path, 'test1/sub1')

        self.assertTrue(self.__check_path('test1', 'sub1'))

class TestUser(unittest.TestCase):

    def test_create_and_remove(self):

        usr = UserModel().create_or_update(username=u'test_user', password=u'qweqwe',

                                     email=u'u232@rhodecode.org',

                                     name=u'u1', lastname=u'u1')

        self.assertEqual(User.get_by_username(u'test_user'), usr)

        # make users group

        Session().commit()

        UsersGroupModel().add_user_to_group(users_group, usr)

        self.assertEqual(UsersGroup.get(users_group.users_group_id), users_group)

        self.assertEqual(UsersGroupMember.query().count(), 1)

        UserModel().delete(usr.user_id)

        self.assertEqual(UsersGroupMember.query().all(), [])

class TestNotifications(unittest.TestCase):

    def __init__(self, methodName='runTest'):

        self.u1 = UserModel().create_or_update(username=u'u1',

                                        password=u'qweqwe',

                                        email=u'u1@rhodecode.org',

        self.u2 = UserModel().create_or_update(username=u'u2',

                                        password=u'qweqwe',

                                        email=u'u2@rhodecode.org',

        self.u3 = UserModel().create_or_update(username=u'u3',

                                        password=u'qweqwe',

                                        email=u'u3@rhodecode.org',

        super(TestNotifications, self).__init__(methodName=methodName)

    def _clean_notifications(self):

        for n in Notification.query().all():

            Session().delete(n)

import os

import logging

from rhodecode.config.environment import load_environment

from rhodecode.lib.db_manage import DbManage

log = logging.getLogger(__name__)

def setup_app(command, conf, vars):

    dbmanage.set_db_version()

    dbmanage.create_settings(dbmanage.config_prompt(None))

    dbmanage.create_default_user()

    dbmanage.admin_prompt()

    dbmanage.create_permissions()

    dbmanage.populate_default_permissions()

    load_environment(conf.global_conf, conf.local_conf, initial=True)