from rhodecode.lib.vcs.exceptions import VCSError

from rhodecode.lib.caching_query import FromCache

from rhodecode.model import meta

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

from rhodecode.model.meta import Session

from rhodecode.model.repos_group import ReposGroupModel

from rhodecode.lib.utils2 import safe_str, safe_unicode

from rhodecode.lib.vcs.utils.fakemod import create_module

log = logging.getLogger(__name__)

    :param ipaddr: optional ip address from what the action was made

    :param sa: optional sqlalchemy session

    """

    if not sa:

    try:

        if hasattr(user, 'user_id'):

            user_obj = user

        elif isinstance(user, basestring):

            user_obj = User.get_by_username(user)

        for section in ui_sections:

            for k, v in cfg.items(section):

                log.debug('settings ui from file[%s]%s:%s' % (section, k, v))

                baseui.setconfig(section, k, v)

    elif read_from == 'db':

        ret = sa.query(RhodeCodeUi)\

            .options(FromCache("sql_cache_short", "get_hg_ui_settings"))\

            .all()

        hg_ui = ret

        for ui_ in hg_ui:

    Given a full path to a repository, create all nested groups that this

    repo is inside. This function creates parent-child relationships between

    groups and creates default perms for all new groups.

    :param paths: full path to repository

    """

    groups = path.split(Repository.url_sep())

    parent = None

    group = None

    # last element is repo in nested groups structure

    groups = groups[:-1]

    that are not in initial_repo_list and removes them.

    :param initial_repo_list: list of repositories found by scanning methods

    :param remove_obsolete: check for obsolete entries in database

    """

    from rhodecode.model.repo import RepoModel

    rm = RepoModel()

    user = sa.query(User).filter(User.admin == True).first()

    if user is None:

        raise Exception('Missing administrative account !')

    added = []

    for name, repo in initial_repo_list.items():

        group = map_groups(name)

            added.append(name)

    sa.commit()

    removed = []

    if remove_obsolete:

        # remove from database those repositories that are not in the filesystem

        for repo in sa.query(Repository).all():

            if repo.repo_name not in initial_repo_list.keys():

    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']

                    landing_rev='tip', just_db=False, fork_of=None,

                    copy_fork_permissions=False):

        from rhodecode.model.scm import ScmModel

        owner = self._get_user(owner)

        fork_of = self._get_repo(fork_of)

        try:

            # repo name is just a name of repository

            # while repo_name_full is a full qualified name that is combined

            # with name and path of group

            repo_name = repo_name.split(self.URL_SEPARATOR)[-1]

            new_repo = Repository()

            new_repo.enable_statistics = False

            new_repo.repo_name = repo_name_full

            new_repo.repo_type = repo_type

            new_repo.user = owner

            new_repo.description = description or repo_name

            new_repo.private = private

            new_repo.clone_uri = clone_uri

            new_repo.landing_rev = landing_rev

            if fork_of:

                    _create_default_perms()

            else:

                _create_default_perms()

            if not just_db:

                self.__create_repo(repo_name, repo_type,

                                   clone_uri)

                log_create_repository(new_repo.get_dict(),

                                      created_by=owner.username)

            # now automatically start following this repository as owner

            ScmModel(self.sa).toggle_following_repo(new_repo.repo_id,

                                                    owner.user_id)

            return new_repo

        except:

            log.error(traceback.format_exc())

            raise

    def create(self, form_data, cur_user, just_db=False, fork=None):

        repo_name = form_data['repo_name_full']

                    .one()

            self.sa.delete(obj)

        except:

            log.error(traceback.format_exc())

            raise

        """

        makes repository on filesystem. It's group aware means it'll create

        a repository within a group, and alter the paths accordingly of

        group location

        :param repo_name:

        :param alias:

        :param parent_id:

        :param clone_uri:

        """

        from rhodecode.lib.utils import is_valid_repo, is_valid_repos_group

        else:

            new_parent_path = ''

        # we need to make it str for mercurial

        repo_path = os.path.join(*map(lambda x: safe_str(x),

                                [self.repos_path, new_parent_path, repo_name]))

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

        if os.path.isdir(rm_path):

            # delete only if that path really exists

            os.rmdir(rm_path)

        try:

            new_repos_group = RepoGroup()

            new_repos_group.group_description = group_description

            new_repos_group.parent_group = self.__get_repos_group(parent)

            new_repos_group.group_name = new_repos_group.get_new_name(group_name)

import random

import mock

from rhodecode.tests import *

from rhodecode.lib.compat import json

from rhodecode.lib.auth import AuthUser

from rhodecode.model.user import UserModel

from rhodecode.model.users_group import UsersGroupModel

from rhodecode.model.repo import RepoModel

API_URL = '/_admin/api'

def _build_data(apikey, method, **kw):

    """

        )

        expected = ret

        self._compare_ok(id_, expected, given=response.body)

        UserModel().delete(usr.user_id)

    @mock.patch.object(UserModel, 'create_or_update', crash)

    def test_api_create_user_when_exception_happened(self):

        username = 'test_new_api_user'

        email = username + "@foo.com"

    def test_api_delete_user(self):

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

                                           password=u'qweqwe',

                                           email=u'u232@rhodecode.org',

                                           firstname=u'u1', lastname=u'u1')

        username = usr.username

        email = usr.email

        usr_id = usr.user_id

        ## DELETE THIS USER NOW

        id_, params = _build_data(self.apikey, 'delete_user',

    @mock.patch.object(UserModel, 'delete', crash)

    def test_api_delete_user_when_exception_happened(self):

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

                                           password=u'qweqwe',

                                           email=u'u232@rhodecode.org',

                                           firstname=u'u1', lastname=u'u1')

        username = usr.username

        id_, params = _build_data(self.apikey, 'delete_user',

                                  userid=username,)

        response = self.app.post(API_URL, content_type='application/json',

                                 params=params)

    def test_api_get_repo(self):

        new_group = 'some_new_group'

        make_users_group(new_group)

        RepoModel().grant_users_group_permission(repo=self.REPO,

                                                 group_name=new_group,

                                                 perm='repository.read')

        id_, params = _build_data(self.apikey, 'get_repo',

                                  repoid=self.REPO)

        response = self.app.post(API_URL, content_type='application/json',

                                 params=params)

        repo = RepoModel().get_by_repo_name(self.REPO)

            users_group = UsersGroupModel().get_group(gr_name)

            ret = users_group.get_api_data()

            expected.append(ret)

        self._compare_ok(id_, expected, given=response.body)

        UsersGroupModel().delete(users_group='test_users_group2')

    def test_api_create_users_group(self):

        group_name = 'some_new_group'

        id_, params = _build_data(self.apikey, 'create_users_group',

                                  group_name=group_name)

        response = self.app.post(API_URL, content_type='application/json',

        expected = 'failed to create group `%s`' % group_name

        self._compare_error(id_, expected, given=response.body)

    def test_api_add_user_to_users_group(self):

        gr_name = 'test_group'

        UsersGroupModel().create(gr_name)

        id_, params = _build_data(self.apikey, 'add_user_to_users_group',

                                  usersgroupid=gr_name,

                                  userid=TEST_USER_ADMIN_LOGIN)

        response = self.app.post(API_URL, content_type='application/json',

                                 params=params)

                                TEST_USER_ADMIN_LOGIN, gr_name

                            ),

                    'success': True}

        self._compare_ok(id_, expected, given=response.body)

        UsersGroupModel().delete(users_group=gr_name)

    def test_api_add_user_to_users_group_that_doesnt_exist(self):

        id_, params = _build_data(self.apikey, 'add_user_to_users_group',

                                  usersgroupid='false-group',

                                  userid=TEST_USER_ADMIN_LOGIN)

        response = self.app.post(API_URL, content_type='application/json',

        self._compare_error(id_, expected, given=response.body)

    @mock.patch.object(UsersGroupModel, 'add_user_to_group', crash)

    def test_api_add_user_to_users_group_exception_occurred(self):

        gr_name = 'test_group'

        UsersGroupModel().create(gr_name)

        id_, params = _build_data(self.apikey, 'add_user_to_users_group',

                                  usersgroupid=gr_name,

                                  userid=TEST_USER_ADMIN_LOGIN)

        response = self.app.post(API_URL, content_type='application/json',

                                 params=params)

        expected = 'failed to add member to users group `%s`' % gr_name

        self._compare_error(id_, expected, given=response.body)

        UsersGroupModel().delete(users_group=gr_name)

    def test_api_remove_user_from_users_group(self):

        gr_name = 'test_group_3'

        gr = UsersGroupModel().create(gr_name)

        UsersGroupModel().add_user_to_group(gr, user=TEST_USER_ADMIN_LOGIN)

        id_, params = _build_data(self.apikey, 'remove_user_from_users_group',

                                  usersgroupid=gr_name,

                                  userid=TEST_USER_ADMIN_LOGIN)

        response = self.app.post(API_URL, content_type='application/json',

                                 params=params)

                                TEST_USER_ADMIN_LOGIN, gr_name

                            ),

                    'success': True}

        self._compare_ok(id_, expected, given=response.body)

        UsersGroupModel().delete(users_group=gr_name)

    @mock.patch.object(UsersGroupModel, 'remove_user_from_group', crash)

    def test_api_remove_user_from_users_group_exception_occurred(self):

        gr_name = 'test_group_3'

        gr = UsersGroupModel().create(gr_name)

        UsersGroupModel().add_user_to_group(gr, user=TEST_USER_ADMIN_LOGIN)

        id_, params = _build_data(self.apikey, 'remove_user_from_users_group',

                                  usersgroupid=gr_name,

                                  userid=TEST_USER_ADMIN_LOGIN)

        response = self.app.post(API_URL, content_type='application/json',

                                 params=params)

        expected = 'failed to remove member from users group `%s`' % gr_name

        self._compare_error(id_, expected, given=response.body)

        UsersGroupModel().delete(users_group=gr_name)

    @parameterized.expand([('none', 'repository.none'),

                           ('read', 'repository.read'),

                           ('write', 'repository.write'),

                           ('admin', 'repository.admin')])

    def test_api_grant_user_permission(self, name, perm):

        self._compare_error(id_, expected, given=response.body)

    def test_api_revoke_users_group_permission(self):

        RepoModel().grant_users_group_permission(repo=self.REPO,

                                                 group_name=TEST_USERS_GROUP,

                                                 perm='repository.read')

        id_, params = _build_data(self.apikey, 'revoke_users_group_permission',

                                  repoid=self.REPO,

                                  usersgroupid=TEST_USERS_GROUP,)

        response = self.app.post(API_URL, content_type='application/json',

                                 params=params)

from rhodecode.tests import *

from rhodecode.model.user import UserModel

from rhodecode.model.notification import NotificationModel

class TestNotificationsController(TestController):

    def tearDown(self):

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

            inst = Notification.get(n.notification_id)

    def test_index(self):

        self.log_user()

        u1 = UserModel().create_or_update(username='u1', password='qweqwe',

                                               email='u1@rhodecode.org',

        cur_user = self._get_logged_user()

        NotificationModel().create(created_by=u1, subject=u'test_notification_1',

                                   body=u'notification_1',

                                   recipients=[cur_user])

        response = self.app.get(url('notifications'))

        self.assertTrue(u'test_notification_1' in response.body)

#    def test_index_as_xml(self):

#        response = self.app.get(url('formatted_notifications', format='xml'))

#

        # make notifications

        notification = NotificationModel().create(created_by=cur_user,

                                                  subject=u'test',

                                                  body=u'hi there',

                                                  recipients=[cur_user, u1, u2])

        u1 = User.get(u1.user_id)

        u2 = User.get(u2.user_id)

        # check DB

        get_notif = lambda un: [x.notification for x in un]

        self.assertEqual(get_notif(cur_user.notifications), [notification])

# -*- coding: utf-8 -*-

import os

from rhodecode.lib import vcs

from rhodecode.tests import *

class TestAdminReposController(TestController):

    def __make_repo(self):

        pass

                                                'private': private,

                                                'landing_rev': 'tip'})

        self.checkSessionFlash(response,

                               'created repository %s' % (repo_name))

        #test if the repo was created in the database

            .filter(Repository.repo_name == repo_name).one()

        self.assertEqual(new_repo.repo_name, repo_name)

        self.assertEqual(new_repo.description, description)

        #test if repository is visible in the list ?

                                                'private': private,

                                                'landing_rev': 'tip'})

        self.checkSessionFlash(response,

                               'created repository %s' % (repo_name_unicode))

        #test if the repo was created in the database

            .filter(Repository.repo_name == repo_name_unicode).one()

        self.assertEqual(new_repo.repo_name, repo_name_unicode)

        self.assertEqual(new_repo.description, description_unicode)

        #test if repository is visible in the list ?

        try:

            vcs.get_repo(os.path.join(TESTS_TMP_PATH, repo_name))

        except:

            self.fail('no repo %s in filesystem' % repo_name)

    def test_create_hg_in_group(self):

    def test_create_git(self):

        self.log_user()

        repo_name = NEW_GIT_REPO

        description = 'description for newly created repo'

        private = False

                                                'private': private,

                                                'landing_rev': 'tip'})

        self.checkSessionFlash(response,

                               'created repository %s' % (repo_name))

        #test if the repo was created in the database

            .filter(Repository.repo_name == repo_name).one()

        self.assertEqual(new_repo.repo_name, repo_name)

        self.assertEqual(new_repo.description, description)

        #test if repository is visible in the list ?

                                                'private': private,

                                                'landing_rev': 'tip'})

        self.checkSessionFlash(response,

                               'created repository %s' % (repo_name_unicode))

        #test if the repo was created in the database

            .filter(Repository.repo_name == repo_name_unicode).one()

        self.assertEqual(new_repo.repo_name, repo_name_unicode)

        self.assertEqual(new_repo.description, description_unicode)

        #test if repository is visible in the list ?

                                                'private': private,

                                                'landing_rev': 'tip'})

        self.checkSessionFlash(response,

                               'created repository %s' % (repo_name))

        #test if the repo was created in the database

            .filter(Repository.repo_name == repo_name).one()

        self.assertEqual(new_repo.repo_name, repo_name)

        self.assertEqual(new_repo.description, description)

        #test if repository is visible in the list ?

        self.assertTrue('''deleted repository %s''' % (repo_name) in

                        response.session['flash'][0])

        response.follow()

        #check if repo was deleted from db

            .filter(Repository.repo_name == repo_name).scalar()

        self.assertEqual(deleted_repo, None)

        self.assertEqual(os.path.isdir(os.path.join(TESTS_TMP_PATH, repo_name)),

                                  False)

                                                'private': private,

                                                'landing_rev': 'tip'})

        self.checkSessionFlash(response,

                               'created repository %s' % (repo_name))

        #test if the repo was created in the database

            .filter(Repository.repo_name == repo_name).one()

        self.assertEqual(new_repo.repo_name, repo_name)

        self.assertEqual(new_repo.description, description)

        #test if repository is visible in the list ?

        self.assertTrue('''deleted repository %s''' % (repo_name) in

                        response.session['flash'][0])

        response.follow()

        #check if repo was deleted from db

            .filter(Repository.repo_name == repo_name).scalar()

        self.assertEqual(deleted_repo, None)

        self.assertEqual(os.path.isdir(os.path.join(TESTS_TMP_PATH, repo_name)),

                                  False)

# -*- coding: utf-8 -*-

from rhodecode.tests import *

from rhodecode.model.db import User, Notification

from rhodecode.lib.utils2 import generate_api_key

from rhodecode.lib.auth import check_password

from rhodecode.lib import helpers as h

from rhodecode.model import validators

class TestLoginController(TestController):

    def tearDown(self):

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

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

    def test_index(self):

        response = self.app.get(url(controller='login', action='index'))

        self.assertEqual(response.status, '200 OK')

        # Test response...

                                             'name': name,

                                             'lastname': lastname,

                                             'admin': True})  # This should be overriden

        self.assertEqual(response.status, '302 Found')

        self.checkSessionFlash(response, 'You have successfully registered into rhodecode')

        self.assertEqual(ret.username, username)

        self.assertEqual(check_password(password, ret.password), True)

        self.assertEqual(ret.email, email)

        self.assertEqual(ret.name, name)

        self.assertEqual(ret.lastname, lastname)

        self.assertNotEqual(ret.api_key, None)

        new.username = username

        new.password = password

        new.email = email

        new.name = name

        new.lastname = lastname

        new.api_key = generate_api_key(username)

        response = self.app.post(url(controller='login',

                                     action='password_reset'),

                                 {'email': email, })

        self.checkSessionFlash(response, 'Your password reset link was sent')

        # add repo to group

        name = RepoGroup.url_sep().join([self.g1.group_name, 'test_perm'])

        self.test_repo = RepoModel().create_repo(

            repo_name=name,

            repo_type='hg',

            description='',

            owner=self.u1,

        )

        Session().commit()

        u1_auth = AuthUser(user_id=self.u1.user_id)

        self.assertEqual(u1_auth.permissions['repositories_groups'],