encoding="UTF-8")

        except Exception:

            log.error(traceback.format_exc())

                    category='error')

        return redirect(url('defaults'))

                        Session().add(setting)

                Session().commit()

                        category='success')

                if not ldap_active:

                    #if ldap is missing send an info to user

                encoding="UTF-8")

        except Exception:

            log.error(traceback.format_exc())

                    category='error')

        return redirect(url('ldap_home'))

                    encoding="UTF-8")

            except Exception:

                log.error(traceback.format_exc())

                        category='error')

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

            new_repo = RepoModel().create(form_result,

                                          self.rhodecode_user.user_id)

            if form_result['clone_uri']:

                    % (form_result['repo_name'], form_result['clone_uri']),

                    category='success')

            else:

                repo_url = h.link_to(form_result['repo_name'],

                    h.url('summary_home', repo_name=form_result['repo_name']))

                        category='success')

            if request.POST.get('user_created'):

        except Exception:

            log.error(traceback.format_exc())

                    % repo_name, category='error')

        return redirect(url('edit_repo', repo_name=changed_name))

                        log.debug('Detaching fork %s from repo %s' % (r, repo))

                        r.fork = None

                        Session().add(r)

                elif do == 'delete_forks':

                    for r in repo.forks:

                        log.debug('Deleting fork %s of repo %s' % (r, repo))

                        repo_model.delete(r)

            action_logger(self.rhodecode_user, 'admin_deleted_repo',

                              repo_name, self.ip_addr, self.sa)

            repo_model.delete(repo)

            invalidate_cache('get_repo_cached_%s' % repo_name)

            Session().commit()

        except IntegrityError, e:

            if e.message.find('repositories_fork_id_fkey') != -1:

                    owner=self.rhodecode_user.user_id

            )

            Session().commit()

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

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

        except formencode.Invalid, errors:

                encoding="UTF-8")

        except Exception:

            log.error(traceback.format_exc())

                    % request.POST.get('group_name'), category='error')

        parent_group_id = form_result['group_parent_id']

        #TODO: maybe we should get back to the main view, not the admin one

            new_gr = ReposGroupModel().update(group_name, form_result)

            Session().commit()

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

            # we now have new name !

            group_name = new_gr.group_name

                encoding="UTF-8")

        except Exception:

            log.error(traceback.format_exc())

                    % request.POST.get('group_name'), category='error')

        return redirect(url('edit_repos_group', group_name=group_name))

        try:

            ReposGroupModel().delete(group_name)

            Session().commit()

                    category='success')

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

        except Exception:

            log.error(traceback.format_exc())

                      'group %s') % group_name, category='error')

        return redirect(url('repos_groups'))

            except Exception:

                log.error(traceback.format_exc())

                          'application settings'),

                          category='error')

            except Exception:

                log.error(traceback.format_exc())

                          'visualisation settings'),

                        category='error')

            except Exception:

                log.error(traceback.format_exc())

                          'application settings'), category='error')

        if setting_id == 'hooks':

                Session().commit()

            except Exception:

                log.error(traceback.format_exc())

                        category='error')

            return redirect(url('admin_edit_setting', setting_id='hooks'))

            return render('admin/users/user_edit_my_account.html')

        except Exception:

            log.error(traceback.format_exc())

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

        return redirect(url('my_account'))

            usr = form_result['username']

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

                          None, self.ip_addr, self.sa)

                    category='success')

            Session().commit()

        except formencode.Invalid, errors:

                encoding="UTF-8")

        except Exception:

            log.error(traceback.format_exc())

                    % request.POST.get('username'), category='error')

        return redirect(url('users'))

                encoding="UTF-8")

        except Exception:

            log.error(traceback.format_exc())

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

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

        try:

            UserModel().delete(usr)

            Session().commit()

        except (UserOwnsReposException, DefaultUserException), e:

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

        except Exception:

            action_logger(self.rhodecode_user,

                          'admin_created_users_group:%s' % gr,

                          None, self.ip_addr, self.sa)

            Session().commit()

        except formencode.Invalid, errors:

            return htmlfill.render(

                encoding="UTF-8")

        except Exception:

            log.error(traceback.format_exc())

                    % request.POST.get('users_group_name'), category='error')

        return redirect(url('users_groups'))

            action_logger(self.rhodecode_user,

                          'admin_updated_users_group:%s' % gr,

                          None, self.ip_addr, self.sa)

            Session().commit()

        except formencode.Invalid, errors:

            ug_model = UserGroupModel()

                encoding="UTF-8")

        except Exception:

            log.error(traceback.format_exc())

                    % request.POST.get('users_group_name'), category='error')

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

        try:

            UserGroupModel().delete(usr_gr)

            Session().commit()

        except UserGroupsAssignedException, e:

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

        except Exception:

            fork_url = h.link_to(form_result['repo_name'],

                    h.url('summary_home', repo_name=form_result['repo_name_full']))

                      % (repo_name, fork_url)),

                    category='success')

        except formencode.Invalid, errors:

        except Exception:

            log.error(traceback.format_exc())

                    % repo_name, category='error')

        return redirect(url('repo_settings_home', repo_name=changed_name))

                              repo_name, self.ip_addr, self.sa)

            repo_model.delete(repo)

            invalidate_cache('get_repo_cached_%s' % repo_name)

            Session().commit()

        except Exception:

            log.error(traceback.format_exc())

msgstr ""

#: rhodecode/controllers/admin/ldap_settings.py:126

msgstr ""

#: rhodecode/controllers/admin/ldap_settings.py:130

msgstr "START_TLS à la connexion"

#: rhodecode/controllers/admin/ldap_settings.py:126

msgstr "Mise à jour réussie des réglages LDAP"

#: rhodecode/controllers/admin/ldap_settings.py:130

msgstr "LDAP接続でSTART_TLSを使用"

#: rhodecode/controllers/admin/ldap_settings.py:126

msgstr "LDAP設定を更新しました"

#: rhodecode/controllers/admin/ldap_settings.py:130

msgstr "START_TLS dla połączenia LDAP"

#: rhodecode/controllers/admin/ldap_settings.py:126

msgstr "Ustawienia LDAP zostały zaktualizowane"

#: rhodecode/controllers/admin/ldap_settings.py:130

msgstr "START_TLS na conexão LDAP"

#: rhodecode/controllers/admin/ldap_settings.py:126

msgstr "Configurações de LDAP atualizadas com sucesso"

#: rhodecode/controllers/admin/ldap_settings.py:130

msgstr ""

#: rhodecode/controllers/admin/ldap_settings.py:126

msgstr ""

#: rhodecode/controllers/admin/ldap_settings.py:130

msgstr "LDAP连接上的START_TLS"

#: rhodecode/controllers/admin/ldap_settings.py:126

msgstr "LDAP设置已经成功更新"

#: rhodecode/controllers/admin/ldap_settings.py:130

msgstr ""

#: rhodecode/controllers/admin/ldap_settings.py:126

msgstr "LDAP設定更新完成"

#: rhodecode/controllers/admin/ldap_settings.py:130

                </div>

            </div>

            <div class="buttons">

            </div>

        </div>

    </div>

                         'fail db write compare')

        self.checkSessionFlash(response,

    def test_ldap_error_form(self):

        self.log_user()

                                                repo_name=repo_name,

                                                repo_description=description))

        self.checkSessionFlash(response,

                               % (repo_name, repo_name))

        #test if the repo was created in the database

                                                repo_name=repo_name,

                                                repo_description=description))

        self.checkSessionFlash(response,

                               % (urllib.quote(repo_name), repo_name_unicode))

        #test if the repo was created in the database

        new_repo = self.Session().query(Repository)\

                                                repo_group=gr.group_id,))

        self.checkSessionFlash(response,

                               % (repo_name, repo_name))

        #test if the repo was created in the database

        new_repo = self.Session().query(Repository)\

                                                repo_name=repo_name,

                                                repo_description=description))

        self.checkSessionFlash(response,

                               % (repo_name, repo_name))

        #test if the repo was created in the database

                                                repo_description=description))

        self.checkSessionFlash(response,

                               % (urllib.quote(repo_name), repo_name_unicode))

        #test if the repo was created in the database

                                                repo_description=description))

        self.checkSessionFlash(response,

                               % (repo_name, repo_name))

        #test if the repo was created in the database

        new_repo = self.Session().query(Repository)\

        response = self.app.delete(url('repo', repo_name=repo_name))

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

        response.follow()

                                                repo_description=description))

        self.checkSessionFlash(response,

                               % (repo_name, repo_name))

        #test if the repo was created in the database

        new_repo = self.Session().query(Repository)\

        response = self.app.delete(url('repo', repo_name=repo_name))

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

        response.follow()

                               'lastname': lastname,

                               'email': email})

        new_user = self.Session.query(User).\

            filter(User.username == username).one()

            .filter(User.username == username).one()

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

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

    def test_delete_browser_fakeout(self):

        response.follow()

        self.checkSessionFlash(response,

    def test_new(self):

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

        response.follow()

        self.checkSessionFlash(response,

        gr = self.Session.query(UserGroup)\

                           .filter(UserGroup.users_group_name ==

        ug = UserGroup.get_by_group_name(users_group_name)

        self.checkSessionFlash(response,

        ## ENABLE REPO CREATE ON A GROUP

        response = self.app.put(url('users_group_perm', id=ug.users_group_id),

                                 {'create_repo_perm': True})

        ug = UserGroup.get_by_group_name(users_group_name)

        self.checkSessionFlash(response,

        ## ENABLE REPO CREATE ON A GROUP

        response = self.app.put(url('users_group_perm', id=ug.users_group_id),

                                 {'fork_repo_perm': True})

        #test if we have a message that fork is ok

        self.checkSessionFlash(response,

                % (repo_name, fork_name, fork_name))

        #test if the fork was created in the database