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

            else:

                action_logger(self.rhodecode_user, 'admin_created_repo',

                              form_result['repo_name_full'], '', self.sa)

        except formencode.Invalid, errors:

            c.new_repo = errors.value['repo_name']

            changed_name = repo.repo_name

            action_logger(self.rhodecode_user, 'admin_updated_repo',

                              changed_name, '', self.sa)

        except formencode.Invalid, errors:

            defaults = self.__load_data(repo_name)

            defaults.update(errors.value)

            repo_model.delete(repo)

            invalidate_cache('get_repo_cached_%s' % repo_name)

            h.flash(_('deleted repository %s') % repo_name, category='success')

        except IntegrityError, e:

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

                log.error(traceback.format_exc())

        try:

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

            ReposGroupModel().create(form_result)

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

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

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

        try:

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

            ReposGroupModel().update(id, form_result)

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

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

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

        try:

            ReposGroupModel().delete(id)

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

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

        except IntegrityError, e:

from rhodecode.model.user import UserModel

from rhodecode.model.db import User

from rhodecode.model.notification import EmailNotificationModel

log = logging.getLogger(__name__)

                if update:

                    h.flash(_('Updated hooks'), category='success')

            except:

                log.error(traceback.format_exc())

                h.flash(_('error occurred during hook creation'),

            user_model.update_my_account(uid, form_result)

            h.flash(_('Your account was updated successfully'),

                    category='success')

        except formencode.Invalid, errors:

            c.user = User.get(self.rhodecode_user.user_id)

            all_repos = self.sa.query(Repository)\

from rhodecode.model.db import User, UserRepoToPerm, UserToPerm, Permission

from rhodecode.model.forms import UserForm

from rhodecode.model.user import UserModel

log = logging.getLogger(__name__)

            user_model.create(form_result)

            h.flash(_('created user %s') % form_result['username'],

                    category='success')

            #action_logger(self.rhodecode_user, 'new_user', '', '', self.sa)

        except formencode.Invalid, errors:

            return htmlfill.render(

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

            user_model.update(id, form_result)

            h.flash(_('User updated successfully'), category='success')

        except formencode.Invalid, errors:

            e = errors.error_dict or {}

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

            return htmlfill.render(

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

                defaults=errors.value,

        try:

            user_model.delete(id)

            h.flash(_('successfully deleted user'), category='success')

        except (UserOwnsReposException, DefaultUserException), e:

            h.flash(str(e), category='warning')

        except Exception:

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

        """GET /users/id/edit: Form to edit an existing item"""

        # url('edit_user', id=ID)

        if not c.user:

            return redirect(url('users'))

        if c.user.username == 'default':

            h.flash(_("You can't edit this user"), category='warning')

            return redirect(url('users'))

        c.user.permissions = {}

            .permissions['global']

        defaults = c.user.get_dict()

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

        return htmlfill.render(

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

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

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

        if grant_perm:

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

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

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

                    category='success')

        else:

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

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

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

                    category='success')

from pylons.i18n.translation import _

from rhodecode.lib.exceptions import UsersGroupsAssignedException

from rhodecode.lib.auth import LoginRequired, HasPermissionAllDecorator

from rhodecode.lib.base import BaseController, render

from rhodecode.model.db import User, UsersGroup, Permission, UsersGroupToPerm

log = logging.getLogger(__name__)

        users_group_form = UsersGroupForm()()

        try:

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

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

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

            #action_logger(self.rhodecode_user, 'new_user', '', '', self.sa)

        except formencode.Invalid, errors:

            return htmlfill.render(

                render('admin/users_groups/users_group_add.html'),

        c.available_members = [(x.user_id, x.username) for x in

                               self.sa.query(User).all()]

        users_group_form = UsersGroupForm(edit=True,

                                          old_data=c.users_group.get_dict(),

        try:

            form_result = users_group_form.to_python(request.POST)

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

                        % form_result['users_group_name'],

                    category='success')

            #action_logger(self.rhodecode_user, 'new_user', '', '', self.sa)

        except formencode.Invalid, errors:

            e = errors.error_dict or {}

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

            e.update({'create_repo_perm':

            return htmlfill.render(

                render('admin/users_groups/users_group_edit.html'),

        # url('users_group', id=ID)

        try:

            h.flash(_('successfully deleted users group'), category='success')

        except UsersGroupsAssignedException, e:

            h.flash(e, category='error')

        except Exception:

        defaults = c.users_group.get_dict()

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

        defaults.update({'create_repo_perm':

        return htmlfill.render(

            render('admin/users_groups/users_group_edit.html'),

            defaults=defaults,

        if grant_perm:

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

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

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

                    category='success')

        else:

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

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

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

                    category='success')

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

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

        try:

            ug = UsersGroupModel().create(name=name, active=active)

            return dict(id=ug.users_group_id,

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

        except Exception:

                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:

        :param repo_name

        """

        members = []

        for user in repo.repo_to_perm:

                                     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)

        """

        try:

            try:

                user = User.get_by_username(user_name)

            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'

                                        revision=revision,

                                        f_path=request.POST.get('f_path'),

                                        line_no=request.POST.get('line'))

        return redirect(h.url('changeset_home', repo_name=repo_name,

                              revision=revision))

        owner = lambda : co.author.user_id == c.rhodecode_user.user_id

        if h.HasPermissionAny('hg.admin', 'repository.admin')() or owner:

            ChangesetCommentsModel().delete(comment=co)

            return True

        else:

            raise HTTPForbidden()

                try:

                    self.scm_model.toggle_following_user(user_id,

                                                self.rhodecode_user.user_id)

                    return 'ok'

                except:

                    raise HTTPBadRequest()

                try:

                    self.scm_model.toggle_following_repo(repo_id,

                                                self.rhodecode_user.user_id)

                    return 'ok'

                except:

                    raise HTTPBadRequest()

                log.info('user %s is now authenticated and stored in '

                         'session, session attrs %s' % (username, cs))

                user.update_lastlogin()

                if c.came_from:

                    return redirect(c.came_from)

                else:

    @HasPermissionAnyDecorator('hg.admin', 'hg.register.auto_activate',

                               'hg.register.manual_activate')

    def register(self):

        c.auto_active = False

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

            if perm.permission.permission_name == 'hg.register.auto_activate':

            try:

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

                form_result['active'] = c.auto_active

                h.flash(_('You have successfully registered into rhodecode'),

                            category='success')

                return redirect(url('login_home'))

            except formencode.Invalid, errors:

        return render('/register.html')

    def password_reset(self):

        if request.POST:

            password_reset_form = PasswordResetForm()()

            try:

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

                h.flash(_('Your password reset link was sent'),

                            category='success')

                return redirect(url('login_home'))

        return render('/password_reset.html')

    def password_reset_confirmation(self):

        if request.GET and request.GET.get('key'):

            try:

                user = User.get_by_api_key(request.GET.get('key'))

                data = dict(email=user.email)

                h.flash(_('Your password reset was successful, '

                          'new password has been sent to your email'),

                            category='success')

            changed_name = form_result['repo_name_full']

            action_logger(self.rhodecode_user, 'user_updated_repo',

                          changed_name, '', self.sa)

        except formencode.Invalid, errors:

            c.repo_info = repo_model.get_by_repo_name(repo_name)

            c.users_array = repo_model.get_users_js()

            repo_model.delete(repo)

            invalidate_cache('get_repo_cached_%s' % repo_name)

            h.flash(_('deleted repository %s') % repo_name, category='success')

        except Exception:

            log.error(traceback.format_exc())

            h.flash(_('An error occurred during deletion of %s') % repo_name,

from pylons.i18n.translation import _

from rhodecode import __platform__, PLATFORM_WIN, PLATFORM_OTHERS

if __platform__ in PLATFORM_WIN:

    from hashlib import sha256

                if user_model.create_ldap(username, password, user_dn,

                                          user_attrs):

                    log.info('created new ldap user %s', username)

                return True

            except (LdapUsernameError, LdapPasswordError,):

                pass

def login_container_auth(username):

    user = User.get_by_username(username)

    if user is None:

        user_attrs = {

            'name': username,

            'lastname': None,

            'email': None,

        }

        if not user:

            return None

        log.info('User %s was created by container authentication', username)

        return None

    user.update_lastlogin()

    log.debug('User %s is now logged in by container authentication',

              user.username)

    return user

    """

    log.info('getting information about all available permissions')

    try:

        all_perms = sa.query(Permission).all()

    except:

        pass

                        .get_unread_cnt_for_user(c.rhodecode_user.user_id)

        self.cut_off_limit = int(config.get('cut_off_limit'))

        self.scm_model = ScmModel(self.sa)

    def __call__(self, environ, start_response):

    if CELERY_ON:

        engine = engine_from_config(config, 'sqlalchemy.db1.')

        init_model(engine)

    return sa

def get_logger(cls):

        co_day_auth_aggr = {}

        commits_by_day_aggregate = {}

        repo_size = len(repo.revisions)

        #return if repo have no revisions

        if repo_size < 1:

    def init_db(self):

        engine = create_engine(self.dburi, echo=self.log_sql)

        init_model(engine)

    def create_tables(self, override=False):

        """Create a auth database

        """

        log.debug('marking %s for invalidation' % key)

            .filter(cls.cache_key == key).scalar()

        if inv_obj:

            inv_obj.cache_active = False

        :param key:

        """

            .filter(CacheInvalidation.cache_key == key).scalar()

        inv_obj.cache_active = True

        Session.add(inv_obj)

    """

    if not sa:

    try:

        if hasattr(user, 'user_id'):

                baseui.setconfig(section, k, v)

    elif read_from == 'db':

        ret = sa.query(RhodeCodeUi)\

            .options(FromCache("sql_cache_short",

                               "get_hg_ui_settings")).all()

    :param groups: list of groups structure

    """

    parent = None

    group = None

    :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:

    dbmanage.admin_prompt()

    dbmanage.create_permissions()

    dbmanage.populate_default_permissions()

    # PART TWO make test repo

    log.debug('making test vcs repositories')

        if sa is not None:

            self.sa = sa

        else:

    def _get_instance(self, cls, instance):

        """

    @classmethod

    def query(cls):

    @classmethod

    def get(cls, id_):

    @classmethod

    def delete(cls, id_):

        obj = cls.query().get(id_)

class RhodeCodeSetting(Base, BaseModel):

        new_ui.ui_key = key

        new_ui.ui_value = val

class User(Base, BaseModel):

    def update_lastlogin(self):

        """Update user lastlogin"""

        self.last_login = datetime.datetime.now()

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

                                    "get_user_%s" % group_name))

        return q.scalar()

    @classmethod

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

        users_group = cls.query()

                                    "get_users_group_%s" % users_group_id))

        return users_group.get(users_group_id)

class UsersGroupMember(Base, BaseModel):

    __tablename__ = 'users_groups_members'

    __table_args__ = {'extend_existing':True}

        ugm = UsersGroupMember()

        ugm.users_group = group

        ugm.user = user

        return ugm

class Repository(Base, BaseModel):

    @classmethod

    def get_by_repo_name(cls, repo_name):

        q = q.options(joinedload(Repository.fork))\

                .options(joinedload(Repository.user))\

                .options(joinedload(Repository.group))

    @classmethod

    def get_repo_forks(cls, repo_id):

        :param cls:

        """

            .filter(RhodeCodeUi.ui_key == cls.url_sep())

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

        return q.one().ui_value

        Returns base full path for that repository means where it actually

        exists on a filesystem

        """

                                              Repository.url_sep())