@HasPermissionAllDecorator('hg.admin')

    def index(self):

                .options(joinedload(UserLog.user))\

                .options(joinedload(UserLog.repository))\

                .order_by(UserLog.action_date.desc())

from rhodecode.lib.exceptions import LdapImportError

from rhodecode.model.forms import LdapSettingsForm

from rhodecode.model.db import RhodeCodeSetting

log = logging.getLogger(__name__)

                            v = ldap_active

                        setting = RhodeCodeSetting.get_by_name(k)

                        setting.app_settings_value = v

                h.flash(_('Ldap settings updated successfully'),

                        category='success')

                if not ldap_active:

            # mark all read

            nm.mark_all_read_for_user(self.rhodecode_user.user_id,

                                      filter_=request.GET.getall('type'))

            c.user = self.rhodecode_user

            notif = nm.get_for_user(self.rhodecode_user.user_id,

                                    filter_=request.GET.getall('type'))

                             == c.rhodecode_user.user_id)

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

                    NotificationModel().mark_read(c.rhodecode_user.user_id, no)

                    return 'ok'

        except Exception:

            Session.rollback()

                             == c.rhodecode_user.user_id)

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

                    NotificationModel().delete(c.rhodecode_user.user_id, no)

                    return 'ok'

        except Exception:

            Session.rollback()

            if unotification:

                if unotification.read is False:

                    unotification.mark_as_read()

                c.notification = no

                return render('admin/notifications/show_notification.html')

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

                action_logger(self.rhodecode_user, 'admin_created_repo',

                              form_result['repo_name_full'], self.ip_addr,

                              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.ip_addr, 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') != -1:

                log.error(traceback.format_exc())

        try:

            RepoModel().revoke_user_permission(repo=repo_name,

                                               user=request.POST['user_id'])

        except Exception:

            log.error(traceback.format_exc())

            h.flash(_('An error occurred during deletion of repository user'),

            RepoModel().revoke_users_group_permission(

                repo=repo_name, group_name=request.POST['users_group_id']

            )

        except Exception:

            log.error(traceback.format_exc())

            h.flash(_('An error occurred during deletion of repository'

        try:

            RepoModel().delete_stats(repo_name)

        except Exception, e:

            h.flash(_('An error occurred during deletion of repository stats'),

                    category='error')

        try:

            ScmModel().mark_for_invalidation(repo_name)

        except Exception, e:

            h.flash(_('An error occurred during cache invalidation'),

                    category='error')

                self.scm_model.toggle_following_repo(repo_id, user_id)

                h.flash(_('Updated repository visibility in public journal'),

                        category='success')

            except:

                h.flash(_('An error occurred during setting this'

                          ' repository in public journal'),

                    group_description=form_result['group_description'],

                    parent=form_result['group_parent_id']

            )

            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:

            ReposGroupModel().revoke_user_permission(

                repos_group=group_name, user=request.POST['user_id']

            )

        except Exception:

            log.error(traceback.format_exc())

            h.flash(_('An error occurred during deletion of group user'),

                repos_group=group_name,

                group_name=request.POST['users_group_id']

            )

        except Exception:

            log.error(traceback.format_exc())

            h.flash(_('An error occurred during deletion of group'

        c.repo_cnt = 0

            .filter(RepoGroup.group_parent_id == id).all()

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

from rhodecode.model.db import User

from rhodecode.model.notification import EmailNotificationModel

from rhodecode.model.meta import Session

log = logging.getLogger(__name__)

        #    h.form(url('admin_setting', setting_id=ID),

        #           method='put')

        # url('admin_setting', setting_id=ID)

        if setting_id == 'mapping':

            rm_obsolete = request.POST.get('destroy', False)

            log.debug('Rescanning directories with destroy=%s' % rm_obsolete)

            h.flash(_('Repositories successfully'

                      ' rescanned added: %s,removed: %s') % (added, removed),

        if setting_id == 'whoosh':

            repo_location = self.get_hg_ui_settings()['paths_root_path']

            full_index = request.POST.get('full_index', False)

            run_task(tasks.whoosh_index, repo_location, full_index)

        if setting_id == 'global':

            application_form = ApplicationSettingsForm()()

            try:

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

            except formencode.Invalid, errors:

                return htmlfill.render(

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

                     defaults=errors.value,

                     errors=errors.error_dict or {},

                     prefix_error=False,

            try:

                # fix namespaces for hooks

                _f = lambda s: s.replace('.', '_')

        if setting_id == 'hooks':

            ui_key = request.POST.get('new_hook_ui_key')

                if update:

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

                log.error(traceback.format_exc())

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

                        category='error')

        if setting_id == 'hooks':

            hook_id = request.POST.get('hook_id')

            RhodeCodeUi.delete(hook_id)

    @HasPermissionAllDecorator('hg.admin')

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

        # url('admin_settings_my_account')

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

                     .filter(Repository.user_id == c.user.user_id)\

                     .order_by(func.lower(Repository.repo_name)).all()

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

                    % form_result.get('username'), category='error')

        return redirect(url('my_account'))

    @NotAnonymous()

    def my_account_my_repos(self):

            .filter(Repository.user_id == self.rhodecode_user.user_id)\

            .order_by(func.lower(Repository.repo_name))\

            .all()

    @NotAnonymous()

    def get_hg_ui_settings(self):

        if not ret:

            raise Exception('Could not get application ui settings !')

                          None, self.ip_addr, self.sa)

            h.flash(_('created user %s') % usr,

                    category='success')

        except formencode.Invalid, errors:

            return htmlfill.render(

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

            action_logger(self.rhodecode_user, 'admin_updated_user:%s' % usr,

                          None, self.ip_addr, self.sa)

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

        except formencode.Invalid, errors:

            c.user_email_map = UserEmailMap.query()\

                            .filter(UserEmailMap.user == c.user).all()

        user_model = UserModel()

        try:

            user_model.delete(id)

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

        except (UserOwnsReposException, DefaultUserException), e:

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

            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)

            user_model.grant_perm(id, perm)

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

                    category='success')

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

    def add_email(self, id):

        try:

            user_model.add_extra_email(id, email)

            h.flash(_("Added email %s to user") % email, category='success')

        except formencode.Invalid, error:

            msg = error.error_dict['email']

        # url('user_emails_delete', id=ID, method='delete')

        user_model = UserModel()

        user_model.delete_extra_email(id, request.POST.get('del_email'))

        h.flash(_("Removed email from user"), category='success')

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

    def index(self, format='html'):

        """GET /users_groups: All items in the collection"""

        # url('users_groups')

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

    def create(self):

                          'admin_created_users_group:%s' % gr,

                          None, self.ip_addr, self.sa)

            h.flash(_('created users group %s') % gr, category='success')

        except formencode.Invalid, errors:

            return htmlfill.render(

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

                           c.group_members_obj]

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

        available_members = [safe_unicode(x[0]) for x in c.available_members]

                          'admin_updated_users_group:%s' % gr,

                          None, self.ip_addr, self.sa)

            h.flash(_('updated users group %s') % gr, category='success')

        except formencode.Invalid, errors:

            e = errors.error_dict or {}

        try:

            UsersGroupModel().delete(id)

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

        except UsersGroupsAssignedException, e:

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

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

        # url('edit_users_group', id=ID)

        if not c.users_group:

            return redirect(url('users_groups'))

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

                           c.group_members_obj]

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

        defaults = c.users_group.get_dict()

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

        defaults.update({'create_repo_perm':

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

                    category='success')

        else:

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

            UsersGroupModel().revoke_perm(id, perm)

            UsersGroupModel().grant_perm(id, perm)

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

                    category='success')

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

    def init_db(self):

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

        init_model(engine)

    def create_tables(self, override=False, defaults={}):

        """

        paths.ui_key = '/'

        paths.ui_value = path

        self.sa.add(web1)

        self.sa.add(web2)

        self.sa.add(web3)

        self.sa.add(web4)

        self.sa.add(paths)

        self.create_ldap_options()

    </div>

    ${h.end_form()}

    <div class="form">

        <!-- fields -->