defaults.update({'create_repo_perm': UserModel().has_perm(id, perm)})

        return htmlfill.render(

            render('admin/users/user_edit.html'),

            defaults=defaults,

            encoding="UTF-8",

            force_defaults=False

        )

    def update_perm(self, id):

        """PUT /users_perm/id: Update an existing item"""

        # url('user_perm', id=ID, method='put')

        grant_perm = request.POST.get('create_repo_perm', False)

        user_model = UserModel()

        if grant_perm:

            perm = Permission.get_by_key('hg.create.none')

            user_model.revoke_perm(id, perm)

            perm = Permission.get_by_key('hg.create.repository')

            user_model.grant_perm(id, perm)

            h.flash(_("Granted 'repository create' permission to user"),

                    category='success')

        else:

            perm = Permission.get_by_key('hg.create.repository')

            user_model.revoke_perm(id, perm)

            perm = Permission.get_by_key('hg.create.none')

            user_model.grant_perm(id, perm)

            h.flash(_("Revoked 'repository create' permission to user"),

                    category='success')

        return redirect(url('edit_user', id=id))

                confirm = getpass.getpass('Confirm password:')

                if password != confirm:

                    log.error('passwords mismatch')

                    return False

                if len(password) < 6:

                    log.error('password is to short use at least 6 characters')

                    return False

                return password

            username = raw_input('Specify admin username:')

            password = get_password()

            if not password:

                #second try

                password = get_password()

                if not password:

                    sys.exit()

            email = raw_input('Specify admin email:')

            self.create_user(username, password, email, True)

        else:

            log.info('creating admin and regular test users')

    def create_ui_settings(self):

        """Creates ui settings, fills out hooks

        and disables dotencode

        """

        #HOOKS

        hooks1_key = RhodeCodeUi.HOOK_UPDATE

        hooks1_ = self.sa.query(RhodeCodeUi)\

            .filter(RhodeCodeUi.ui_key == hooks1_key).scalar()

        hooks1 = RhodeCodeUi() if hooks1_ is None else hooks1_

        hooks1.ui_section = 'hooks'

        hooks1.ui_key = hooks1_key

        hooks1.ui_value = 'hg update >&2'

        hooks1.ui_active = False

        hooks2_key = RhodeCodeUi.HOOK_REPO_SIZE

        hooks2_ = self.sa.query(RhodeCodeUi)\

            .filter(RhodeCodeUi.ui_key == hooks2_key).scalar()

        hooks2 = RhodeCodeUi() if hooks2_ is None else hooks2_

        hooks2.ui_section = 'hooks'

        hooks2.ui_key = hooks2_key

        method that will return a dict for serialization into json

    example::

        class Task(object):

            def __init__(self, name, value):

                self.name = name

                self.value = value

            def __json__(self):

                return dict(name=self.name,

                            value=self.value)

    """

    def default(self, obj):

        if hasattr(obj, '__json__'):

            return obj.__json__()

        else:

            return json.JSONEncoder.default(self, obj)

class BaseModel(object):

    """

    @classmethod

    def _get_keys(cls):

        """return column names for this model """

        return class_mapper(cls).c.keys()

        d = {}

        for k in self._get_keys():

            d[k] = getattr(self, k)

        return d

    def get_appstruct(self):

        """return list with keys and values tupples corresponding

        to this model data """

        l = []

        for k in self._get_keys():

            l.append((k, getattr(self, k),))

        return l

    def populate_obj(self, populate_dict):

        """populate model with data from given populate_dict"""

        for k in self._get_keys():

            if k in populate_dict:

                setattr(self, k, populate_dict[k])

    @classmethod

    def query(cls):

        return Session.query(cls)

    @classmethod

    def get(cls, id_):

        if cache:

            q = q.options(FromCache("sql_cache_short",

                                    "get_api_key_%s" % api_key))

        return q.scalar()

    @classmethod

    def get_by_email(cls, email, case_insensitive=False, cache=False):

        if case_insensitive:

            q = cls.query().filter(cls.email.ilike(email))

        else:

            q = cls.query().filter(cls.email == email)

        if cache:

            q = q.options(FromCache("sql_cache_short",

                                    "get_api_key_%s" % email))

        return q.scalar()

    def update_lastlogin(self):

        """Update user lastlogin"""

        self.last_login = datetime.datetime.now()

        Session.add(self)

        log.debug('updated user %s lastlogin', self.username)

class UserLog(Base, BaseModel):

    __tablename__ = 'user_logs'

    __table_args__ = {'extend_existing':True}

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

    user_id = Column("user_id", Integer(), ForeignKey('users.user_id'), nullable=False, unique=None, default=None)

    repository_id = Column("repository_id", Integer(), ForeignKey('repositories.repo_id'), nullable=True)

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

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

    action = Column("action", UnicodeText(length=1200000, convert_unicode=False, assert_unicode=None), nullable=True, unique=None, default=None)

    action_date = Column("action_date", DateTime(timezone=False), nullable=True, unique=None, default=None)

    @property

    def action_as_day(self):

        return datetime.date(*self.action_date.timetuple()[:3])

    user = relationship('User')

    repository = relationship('Repository',cascade='')

class UsersGroup(Base, BaseModel):

    __tablename__ = 'users_groups'

    __table_args__ = {'extend_existing':True}

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

        except:

            log.error(traceback.format_exc())

            raise

    def update_my_account(self, user_id, form_data):

        try:

            user = self.get(user_id, cache=False)

            if user.username == 'default':

                raise DefaultUserException(

                                _("You can't Edit this user since it's"

                                  " crucial for entire application"))

            for k, v in form_data.items():

                if k == 'new_password' and v != '':

                    user.password = v

                    user.api_key = generate_api_key(user.username)

                else:

                    if k not in ['admin', 'active']:

                        setattr(user, k, v)

            self.sa.add(user)

        except:

            log.error(traceback.format_exc())

            raise

        try:

            if user.username == 'default':

                raise DefaultUserException(

                                _("You can't remove this user since it's"

                                  " crucial for entire application"))

            if user.repositories:

                raise UserOwnsReposException(_('This user still owns %s '

                                               'repositories and cannot be '

                                               'removed. Switch owners or '

                                               'remove those repositories') \

                                               % user.repositories)

            self.sa.delete(user)

        except:

            log.error(traceback.format_exc())

            raise

    def reset_password_link(self, data):

        from rhodecode.lib.celerylib import tasks, run_task

        run_task(tasks.send_password_link, data['email'])

    def reset_password(self, data):

        from rhodecode.lib.celerylib import tasks, run_task

        run_task(tasks.reset_user_password, data['email'])

    def fill_data(self, auth_user, user_id=None, api_key=None):

            user_repo_perms_from_users_groups = self.sa.query(

                                                UsersGroupRepoToPerm,

                                                Permission, Repository,)\

                .join((Repository, UsersGroupRepoToPerm.repository_id ==

                       Repository.repo_id))\

                .join((Permission, UsersGroupRepoToPerm.permission_id ==

                       Permission.permission_id))\

                .join((UsersGroupMember, UsersGroupRepoToPerm.users_group_id ==

                       UsersGroupMember.users_group_id))\

                .filter(UsersGroupMember.user_id == uid).all()

            for perm in user_repo_perms_from_users_groups:

                p = perm.Permission.permission_name

                cur_perm = user.permissions['repositories'][perm.

                                                    UsersGroupRepoToPerm.

                                                    repository.repo_name]

                # overwrite permission only if it's greater than permission

                # given from other sources

                if PERM_WEIGHTS[p] > PERM_WEIGHTS[cur_perm]:

                    user.permissions['repositories'][perm.UsersGroupRepoToPerm.

                                                     repository.repo_name] = p

        return user

    def has_perm(self, user, perm):

        if not isinstance(perm, Permission):

        user = self.__get_user(user)

            .filter(UserToPerm.permission == perm).scalar() is not None

    def grant_perm(self, user, perm):

        if not isinstance(perm, Permission):

        user = self.__get_user(user)

        new = UserToPerm()

        new.permission = perm

        self.sa.add(new)

    def revoke_perm(self, user, perm):

        if not isinstance(perm, Permission):

        user = self.__get_user(user)

import os

import time

import logging

from os.path import join as jn

from unittest import TestCase

from tempfile import _RandomNameSequence

from paste.deploy import loadapp

from paste.script.appinstall import SetupCommand

from pylons import config, url

from routes.util import URLGenerator

from webtest import TestApp

from rhodecode.model.meta import Session

from rhodecode.model.db import User

import pylons.test

os.environ['TZ'] = 'UTC'

time.tzset()

log = logging.getLogger(__name__)

# Invoke websetup with the current config file

# SetupCommand('setup-app').run([config_file])

##RUNNING DESIRED TESTS

# nosetests -x rhodecode.tests.functional.test_admin_settings:TestSettingsController.test_my_account

# nosetests --pdb --pdb-failures 

environ = {}

#SOME GLOBALS FOR TESTS

TESTS_TMP_PATH = jn('/', 'tmp', 'rc_test_%s' % _RandomNameSequence().next())

TEST_USER_ADMIN_LOGIN = 'test_admin'

TEST_USER_ADMIN_PASS = 'test12'

HG_REPO = 'vcs_test_hg'

GIT_REPO = 'vcs_test_git'

NEW_HG_REPO = 'vcs_test_hg_new'

NEW_GIT_REPO = 'vcs_test_git_new'

HG_FORK = 'vcs_test_hg_fork'

GIT_FORK = 'vcs_test_git_fork'

class TestController(TestCase):

    def __init__(self, *args, **kwargs):

        wsgiapp = pylons.test.pylonsapp

        config = wsgiapp.config

        self.app = TestApp(wsgiapp)

        url._push_object(URLGenerator(config['routes.map'], environ))

        self.Session = Session

        self.index_location = config['app_conf']['index_dir']

        TestCase.__init__(self, *args, **kwargs)

    def log_user(self, username=TEST_USER_ADMIN_LOGIN,

                 password=TEST_USER_ADMIN_PASS):

        self._logged_username = username

from rhodecode.tests import *

from rhodecode.lib.auth import check_password

from sqlalchemy.orm.exc import NoResultFound

class TestAdminUsersController(TestController):

    def test_index(self):

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

        # Test response...

    def test_index_as_xml(self):

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

    def test_create(self):

        self.log_user()

        username = 'newtestuser'

        password = 'test12'

        password_confirmation = password

        name = 'name'

        lastname = 'lastname'

        email = 'mail@mail.com'

        response.follow()

        response = response.follow()

    def test_create_err(self):

        self.log_user()

        username = 'new_user'

        password = ''

        name = 'name'

        lastname = 'lastname'

        email = 'errmail.com'

        response = self.app.post(url('users'), {'username':username,

                                               'password':password,

                                               'name':name,

                                               'active':False,

                                               'lastname':lastname,

                                               'email':email})

        def get_user():

            self.Session.query(User).filter(User.username == username).one()

        self.assertRaises(NoResultFound, get_user), 'found user in database'

    def test_new(self):

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

    def test_new_as_xml(self):

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

    def test_update(self):

        response = self.app.put(url('user', id=1))

    def test_update_browser_fakeout(self):

        response = self.app.post(url('user', id=1), params=dict(_method='put'))

    def test_delete(self):

        self.log_user()

        username = 'newtestuserdeleteme'

        password = 'test12'

        name = 'name'

        lastname = 'lastname'

        email = 'todeletemail@mail.com'

        response = self.app.post(url('users'), {'username':username,

                                               'password':password,

                                               'password_confirmation':password,

                                               'name':name,

                                               'active':True,

                                               'lastname':lastname,

                                               'email':email})

        response = response.follow()

        response = self.app.delete(url('user', id=new_user.user_id))

    def test_delete_browser_fakeout(self):

    def test_show(self):

        response = self.app.get(url('user', id=1))

    def test_show_as_xml(self):

        response = self.app.get(url('formatted_user', id=1, format='xml'))

    def test_edit(self):

    def test_edit_as_xml(self):

        response = self.app.get(url('formatted_edit_user', id=1, format='xml'))

import os

import unittest

from rhodecode.tests import *

from rhodecode.model.repos_group import ReposGroupModel

from rhodecode.model.repo import RepoModel

from rhodecode.model.db import RepoGroup, User, Notification, UserNotification, \

from sqlalchemy.exc import IntegrityError

from rhodecode.model.user import UserModel

from rhodecode.model.meta import Session

from rhodecode.model.notification import NotificationModel

from rhodecode.model.users_group import UsersGroupModel

class TestReposGroups(unittest.TestCase):

    def setUp(self):

        self.g1 = self.__make_group('test1', skip_if_exists=True)

        self.g2 = self.__make_group('test2', skip_if_exists=True)

        self.g3 = self.__make_group('test3', skip_if_exists=True)

    def tearDown(self):

        print 'out'

    def __check_path(self, *path):

        path = [TESTS_TMP_PATH] + list(path)

        path = os.path.join(*path)

        return os.path.isdir(path)

    def _check_folders(self):

        print os.listdir(TESTS_TMP_PATH)

                         private=False,

                         repo_type='hg',

                         clone_uri=None)

        cur_user = User.get_by_username(TEST_USER_ADMIN_LOGIN)

        r = RepoModel().create(form_data, cur_user)

        self.assertEqual(r.repo_name, 'john')

        # put repo into group

        form_data = form_data

        form_data['repo_group'] = g1.group_id

        form_data['perms_new'] = []

        form_data['perms_updates'] = []

        RepoModel().update(r.repo_name, form_data)

        self.assertEqual(r.repo_name, 'g1/john')

        self.__update_group(g1.group_id, 'g1', parent_id=g2.group_id)

        self.assertTrue(self.__check_path('g2', 'g1'))

        # test repo

        self.assertEqual(r.repo_name, os.path.join('g2', 'g1', r.just_name))

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

        Session.commit()

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

        # make users group

        users_group = UsersGroupModel().create('some_example_group')

        Session.commit()

        UsersGroupModel().add_user_to_group(users_group, usr)

        Session.commit()

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

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

        UserModel().delete(usr.user_id)

        Session.commit()

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

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

        Session.commit()

        self.u1 = self.u1.user_id

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

                                        password=u'qweqwe',

                                        email=u'u2@rhodecode.org',

                                        name=u'u2', lastname=u'u3')

        Session.commit()

        self.u2 = self.u2.user_id

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

                                        password=u'qweqwe',

                                        email=u'u3@rhodecode.org',

                                        name=u'u3', lastname=u'u3')

        Session.commit()

        self.u3 = self.u3.user_id

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

    def _clean_notifications(self):

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

            Session.delete(n)

        Session.commit()

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

    def test_create_notification(self):

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

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

        usrs = [self.u1, self.u2]

        notification = NotificationModel().create(created_by=self.u1,

                                           subject=u'subj', body=u'hi there',

                                           recipients=usrs)

        Session.commit()

        u1 = User.get(self.u1)

        u2 = User.get(self.u2)

        u3 = User.get(self.u3)

        notifications = Notification.query().all()

        self.assertEqual(len(notifications), 1)

        unotification = UserNotification.query()\

            .filter(UserNotification.notification == notification).all()

        self.assertEqual(notifications[0].recipients, [u1, u2])

        self.assertEqual(notification.notification_id,

                         notifications[0].notification_id)

        self.assertEqual(len(unotification), len(usrs))

        self.assertEqual([x.user.user_id for x in unotification], usrs)

    def test_user_notifications(self):

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

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

        notification1 = NotificationModel().create(created_by=self.u1,

                                            subject=u'subj', body=u'hi there1',

                                            recipients=[self.u3])

        Session.commit()

        notification2 = NotificationModel().create(created_by=self.u1,

                                            subject=u'subj', body=u'hi there2',

                                            recipients=[self.u3])

        Session.commit()

        u3 = Session.query(User).get(self.u3)

        self.assertEqual(sorted([x.notification for x in u3.notifications]),

                         sorted([notification2, notification1]))

    def test_delete_notifications(self):

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

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

        notification = NotificationModel().create(created_by=self.u1,

                                           subject=u'title', body=u'hi there3',

                                    recipients=[self.u3, self.u1, self.u2])

        Session.commit()

        notifications = Notification.query().all()

        self.assertTrue(notification in notifications)

        Notification.delete(notification.notification_id)

        Session.commit()

        notifications = Notification.query().all()

        self.assertFalse(notification in notifications)

        un = UserNotification.query().filter(UserNotification.notification

                                             == notification).all()

        self.assertEqual(un, [])

    def test_delete_association(self):

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

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

        notification = NotificationModel().create(created_by=self.u1,

                                           subject=u'title', body=u'hi there3',

                                    recipients=[self.u3, self.u1, self.u2])

        Session.commit()

        unotification = UserNotification.query()\

                            .filter(UserNotification.notification ==

                                    notification)\

                            .filter(UserNotification.user_id == self.u3)\

                            .scalar()