def create(self):

        """POST /repos: Create a new item"""

        # url('repos')

        repo_model = RepoModel()

        _form = RepoForm()()

        try:

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

            repo_model.create(form_result, c.hg_app_user)

            invalidate_cache('cached_repo_list')

            h.flash(_('created repository %s') % form_result['repo_name'],

                    category='success')

                errors=errors.error_dict or {},

                prefix_error=False,

                encoding="UTF-8")      

        except Exception:

            log.error(traceback.format_exc())

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

        return redirect('repos')

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

        """GET /repos/new: Form to create a new item"""

#!/usr/bin/env python

# encoding: utf-8

# users controller for pylons

# Copyright (C) 2009-2010 Marcin Kuzminski <marcin@python-works.com>

# This program is free software; you can redistribute it and/or

# modify it under the terms of the GNU General Public License

# as published by the Free Software Foundation; version 2

# of the License or (at your opinion) any later version of the license.

# 

# This program is distributed in the hope that it will be useful,

# GNU General Public License for more details.

# 

# You should have received a copy of the GNU General Public License

# along with this program; if not, write to the Free Software

# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,

# MA  02110-1301, USA.

from formencode import htmlfill

from pylons import request, session, tmpl_context as c, url

from pylons.controllers.util import abort, redirect

from pylons.i18n.translation import _

from pylons_app.lib import helpers as h

from pylons_app.lib.auth import LoginRequired, HasPermissionAllDecorator

from pylons_app.lib.base import BaseController, render

from pylons_app.model.db import User, UserLog

from pylons_app.model.forms import UserForm

from pylons_app.model.user_model import UserModel, DefaultUserException

import formencode

import logging

log = logging.getLogger(__name__)

class UsersController(BaseController):

    """REST Controller styled on the Atom Publishing Protocol"""

    # To properly map this controller, ensure your config/routing.py

        try:

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

            user_model.create(form_result)

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

                    category='success')

        except formencode.Invalid as errors:

            return htmlfill.render(

                defaults=errors.value,

        except Exception:

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

        return redirect(url('users'))

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

        """GET /users/new: Form to create a new item"""

        # url('new_user')

        #    <input type="hidden" name="_method" value="PUT" />

        # Or using helpers:

        #    h.form(url('user', id=ID),

        #           method='put')

        # url('user', id=ID)

        user_model = UserModel()

        try:

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

            user_model.update(id, form_result)

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

        except formencode.Invalid as errors:

            c.user = user_model.get_user(id)

            return htmlfill.render(

                defaults=errors.value,

        except Exception:

            h.flash(_('error occured during update of user %s') \

        return redirect(url('users'))

    def delete(self, id):

        """DELETE /users/id: Delete an existing item"""

        # Forms posted to this method should contain a hidden field:

    def validate_python(self, value, state):

        if value != authentication_token():

            raise formencode.Invalid(self.message('invalid_token', state,

                                            search_number=value), value, state)

class ValidPassword(formencode.validators.FancyValidator):

    def to_python(self, value, state):

        if value:

            return get_crypt_password(value)

                                )

    #chained validators have access to all data

    chained_validators = [ValidAuth]

    class _UserForm(formencode.Schema):

        allow_extra_fields = True

        filter_extra_fields = True

        if edit:

            new_password = All(UnicodeString(strip=True, min=3, not_empty=False), ValidPassword)

            admin = StringBoolean(if_missing=False)

        else:

        active = StringBoolean(if_missing=False)

        name = UnicodeString(strip=True, min=3, not_empty=True)

        lastname = UnicodeString(strip=True, min=3, not_empty=True)

        email = Email(not_empty=True)

    return _UserForm