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

                    category='error')

        return redirect(url('home'))

    def fork(self, repo_name):

        repo_model = RepoModel()

        c.repo_info = repo = repo_model.get(repo_name)

        if not repo:

            h.flash(_('%s repository is not mapped to db perhaps'

                      ' it was created or renamed from the filesystem'

                      ' please run the application again'

                      ' in order to rescan repositories') % repo_name,

                      category='error')

            return redirect(url('home'))

        return render('settings/repo_fork.html')

    def fork_create(self, repo_name):

        repo_model = RepoModel()

        c.repo_info = repo_model.get(repo_name)

        form_result = {}

        try:

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

            form_result.update({'repo_name':repo_name})

            repo_model.create_fork(form_result, c.rhodecode_user)

            h.flash(_('fork %s repository as %s task added') \

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

                    category='success')

            action_logger(self.rhodecode_user, 'user_forked_repo',

                            repo_name, '', self.sa)

        except formencode.Invalid, errors:

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

            r = render('settings/repo_fork.html')

            return htmlfill.render(

                r,

                defaults=errors.value,

                errors=errors.error_dict or {},

                prefix_error=False,

                encoding="UTF-8")

        return redirect(url('home'))

"""The base Controller API

Provides the BaseController class for subclassing.

"""

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

from pylons.controllers import WSGIController

from pylons.templating import render_mako as render

from rhodecode import __version__

from rhodecode.lib import auth

from rhodecode.lib.utils import get_repo_slug

from rhodecode.model import meta

from rhodecode.model.hg import _get_repos_cached, \

    _get_repos_switcher_cached

class BaseController(WSGIController):

    def __before__(self):

        c.rhodecode_version = __version__

        c.rhodecode_name = config['rhodecode_title']

        c.repo_name = get_repo_slug(request)

        c.cached_repo_list = _get_repos_cached()

        c.repo_switcher_list = _get_repos_switcher_cached(c.cached_repo_list)

        if c.repo_name:

            cached_repo = c.cached_repo_list.get(c.repo_name)

            if cached_repo:

                c.repository_tags = cached_repo.tags

                c.repository_branches = cached_repo.branches

            else:

                c.repository_tags = {}

                c.repository_branches = {}

        self.sa = meta.Session()

    def __call__(self, environ, start_response):

        """Invoke the Controller"""

        # WSGIController.__call__ dispatches to the Controller method

        # the request is routed to. This routing information is

        # available in environ['pylons.routes_dict']

        try:

            #putting this here makes sure that we update permissions every time

            self.rhodecode_user = c.rhodecode_user = auth.get_user(session)

            return WSGIController.__call__(self, environ, start_response)

        finally:

            meta.Session.remove()

@task

def send_email(recipients, subject, body):

    log = send_email.get_logger()

    email_config = dict(config.items('DEFAULT'))

    mail_from = email_config.get('app_email_from')

    user = email_config.get('smtp_username')

    passwd = email_config.get('smtp_password')

    mail_server = email_config.get('smtp_server')

    mail_port = email_config.get('smtp_port')

    tls = email_config.get('smtp_use_tls')

    ssl = False

    try:

        m = SmtpMailer(mail_from, user, passwd, mail_server,

                       mail_port, ssl, tls)

        m.send(recipients, subject, body)

    except:

        log.error('Mail sending failed')

        log.error(traceback.format_exc())

        return False

    return True

@task

def create_repo_fork(form_data, cur_user):

    from rhodecode.model.repo import RepoModel

    repo_model = RepoModel(get_session())

    repo_model.create(form_data, cur_user, just_db=True, fork=True)

    repo_fork_path = os.path.join(repos_path, form_data['fork_name'])

def __get_codes_stats(repo_name):

    LANGUAGES_EXTENSIONS = ['action', 'adp', 'ashx', 'asmx',

    'aspx', 'asx', 'axd', 'c', 'cfg', 'cfm', 'cpp', 'cs', 'diff', 'do', 'el',

    'erl', 'h', 'java', 'js', 'jsp', 'jspx', 'lisp', 'lua', 'm', 'mako', 'ml',

    'pas', 'patch', 'php', 'php3', 'php4', 'phtml', 'pm', 'py', 'rb', 'rst',

    's', 'sh', 'tpl', 'txt', 'vim', 'wss', 'xhtml', 'xml', 'xsl', 'xslt', 'yaws']

    repos_path = get_hg_ui_settings()['paths_root_path']

    p = os.path.join(repos_path, repo_name)

    repo = get_repo(p)

    tip = repo.get_changeset()

    code_stats = {}

    def aggregate(cs):

        for f in cs[2]:

            k = f.mimetype

            if f.extension in LANGUAGES_EXTENSIONS:

                if code_stats.has_key(k):

                    code_stats[k] += 1

                else:

                    code_stats[k] = 1

        return self

    def get_file_content(self, path):

        return u''

    def get_file_size(self, path):

        return 0

def repo2db_mapper(initial_repo_list, remove_obsolete=False):

    """

    maps all found repositories into db

    """

    sa = meta.Session()

    rm = RepoModel(sa)

    user = sa.query(User).filter(User.admin == True).first()

    for name, repo in initial_repo_list.items():

        if not rm.get(name, cache=False):

            log.info('repository %s not found creating default', name)

            form_data = {

                         'repo_name':name,

                         'repo_type':repo.alias,

                         'private':False

                         }

            rm.create(form_data, user, just_db=True)

    if remove_obsolete:

        #remove from database those repositories that are not in the filesystem

        for repo in sa.query(Repository).all():

            if repo.repo_name not in initial_repo_list.keys():

                sa.delete(repo)

                sa.commit()

    meta.Session.remove()

class OrderedDict(dict, DictMixin):

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

        if len(args) > 1:

            raise TypeError('expected at most 1 arguments, got %d' % len(args))

        try:

            self.__end

        except AttributeError:

chained_validators      []     These validators will be applied after the schema

allow_extra_fields      False     If True, then it is not an error when keys that aren't associated with a validator are present

filter_extra_fields     False     If True, then keys that aren't associated with a validator are removed

if_key_missing          NoDefault If this is given, then any keys that aren't available but are expected will be replaced with this value (and then validated). This does not override a present .if_missing attribute on validators. NoDefault is a special FormEncode class to mean that no default values has been specified and therefore missing keys shouldn't take a default value.

ignore_key_missing      False     If True, then missing keys will be missing in the result, if the validator doesn't have .if_missing on it already    

<name> = formencode.validators.<name of validator>

<name> must equal form name

list=[1,2,3,4,5]

for SELECT use formencode.All(OneOf(list), Int())

"""

from formencode import All

from formencode.validators import UnicodeString, OneOf, Int, Number, Regex, \

    Email, Bool, StringBoolean

from pylons import session

from pylons.i18n.translation import _

from rhodecode.lib.auth import check_password, get_crypt_password

from rhodecode.model import meta

from rhodecode.model.user import UserModel

from rhodecode.model.repo import RepoModel

from rhodecode.model.db import User

from webhelpers.pylonslib.secure_form import authentication_token

import formencode

import logging

import os

import rhodecode.lib.helpers as h

log = logging.getLogger(__name__)

#this is needed to translate the messages using _() in validators

class State_obj(object):

    _ = staticmethod(_)

#===============================================================================

# VALIDATORS

#===============================================================================

class ValidAuthToken(formencode.validators.FancyValidator):

    messages = {'invalid_token':_('Token mismatch')}

    def validate_python(self, value, state):

        if value != authentication_token():

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

                                            search_number=value), value, state)

def ValidUsername(edit, old_data):

            raise formencode.Invalid(_('This username is not valid'),

                                     value, state)

        finally:

            meta.Session.remove()

        return self.user_db.user_id

def ValidRepoName(edit, old_data):

    class _ValidRepoName(formencode.validators.FancyValidator):

        def to_python(self, value, state):

            slug = h.repo_name_slug(value)

            if slug in ['_admin']:

                raise formencode.Invalid(_('This repository name is disallowed'),

                                         value, state)

            if old_data.get('repo_name') != value or not edit:

                if RepoModel().get(slug, cache=False):

                    raise formencode.Invalid(_('This repository already exists') ,

                                             value, state)

            return slug

    return _ValidRepoName

class ValidPerms(formencode.validators.FancyValidator):

    messages = {'perm_new_user_name':_('This username is not valid')}

    def to_python(self, value, state):

        perms_update = []

        perms_new = []

        #build a list of permission to update and new permission to create

        for k, v in value.items():

            if k.startswith('perm_'):

                if  k.startswith('perm_new_user'):

                    new_perm = value.get('perm_new_user', False)

                    new_user = value.get('perm_new_user_name', False)

                    if new_user and new_perm:

                        if (new_user, new_perm) not in perms_new:

                            perms_new.append((new_user, new_perm))

                else:

                    usr = k[5:]

                    if usr == 'default':

                        if value['private']:

                            #set none for default when updating to private repo

                            v = 'repository.none'

                    perms_update.append((usr, v))

        value['perms_updates'] = perms_update

        value['perms_new'] = perms_new

            password = All(UnicodeString(strip=True, min=6, not_empty=True), ValidPassword)

        active = StringBoolean(if_missing=False)

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

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

        email = All(Email(not_empty=True), UniqSystemEmail(old_data))

    return _UserForm

RegisterForm = UserForm

def PasswordResetForm():

    class _PasswordResetForm(formencode.Schema):

        allow_extra_fields = True

        filter_extra_fields = True

        email = All(ValidSystemEmail(), Email(not_empty=True))

    return _PasswordResetForm

def RepoForm(edit=False, old_data={}):

    class _RepoForm(formencode.Schema):

        allow_extra_fields = True

        filter_extra_fields = False

        repo_name = All(UnicodeString(strip=True, min=1, not_empty=True), ValidRepoName(edit, old_data))

        description = UnicodeString(strip=True, min=1, not_empty=True)

        private = StringBoolean(if_missing=False)

        if edit:

            user = All(Int(not_empty=True), ValidRepoUser)

        chained_validators = [ValidPerms]

    return _RepoForm

def RepoForkForm(edit=False, old_data={}):

    class _RepoForkForm(formencode.Schema):

        allow_extra_fields = True

        filter_extra_fields = False

        fork_name = All(UnicodeString(strip=True, min=1, not_empty=True), ValidRepoName(edit, old_data))

        description = UnicodeString(strip=True, min=1, not_empty=True)

        private = StringBoolean(if_missing=False)

    return _RepoForkForm

def RepoSettingsForm(edit=False, old_data={}):

    class _RepoForm(formencode.Schema):

        allow_extra_fields = True

        filter_extra_fields = False

        repo_name = All(UnicodeString(strip=True, min=1, not_empty=True), ValidRepoName(edit, old_data))

        description = UnicodeString(strip=True, min=1, not_empty=True)

        private = StringBoolean(if_missing=False)

        chained_validators = [ValidPerms, ValidSettings]

    return _RepoForm

def ApplicationSettingsForm():

    class _ApplicationSettingsForm(formencode.Schema):

        allow_extra_fields = True

        filter_extra_fields = False

        rhodecode_title = UnicodeString(strip=True, min=1, not_empty=True)

        rhodecode_realm = UnicodeString(strip=True, min=1, not_empty=True)

    return _ApplicationSettingsForm

def ApplicationUiSettingsForm():

#!/usr/bin/env python

# encoding: utf-8

# model for handling repositories actions

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

# but WITHOUT ANY WARRANTY; without even the implied warranty of

# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

# 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.

"""

Created on Jun 5, 2010

model for handling repositories actions

:author: marcink

"""

from datetime import datetime

from pylons import app_globals as g

from rhodecode.model.db import Repository, RepoToPerm, User, Permission

from rhodecode.model.meta import Session

from rhodecode.model.user import UserModel

from rhodecode.model.caching_query import FromCache

import logging

import os

import shutil

import traceback

log = logging.getLogger(__name__)

class RepoModel(object):

    def __init__(self, sa=None):

        if not sa:

            self.sa = Session()

        else:

            self.sa = sa

    def get(self, repo_id, cache=False):

        repo = self.sa.query(Repository)\

            .filter(Repository.repo_name == repo_id)

            new_repo.user_id = cur_user.user_id

            self.sa.add(new_repo)

            #create default permission

            repo_to_perm = RepoToPerm()

            default = 'repository.read'

            for p in UserModel(self.sa).get_by_username('default', cache=False).user_perms:

                if p.permission.permission_name.startswith('repository.'):

                    default = p.permission.permission_name

                    break

            default_perm = 'repository.none' if form_data['private'] else default

            repo_to_perm.permission_id = self.sa.query(Permission)\

                    .filter(Permission.permission_name == default_perm)\

                    .one().permission_id

            repo_to_perm.repository_id = new_repo.repo_id

            repo_to_perm.user_id = UserModel(self.sa).get_by_username('default', cache=False).user_id

            self.sa.add(repo_to_perm)

            self.sa.commit()

            if not just_db:

        except:

            log.error(traceback.format_exc())

            self.sa.rollback()

            raise

    def create_fork(self, form_data, cur_user):

        from rhodecode.lib.celerylib import tasks, run_task

        run_task(tasks.create_repo_fork, form_data, cur_user)

    def delete(self, repo):

        try:

            self.sa.delete(repo)

            self.sa.commit()

            self.__delete_repo(repo.repo_name)

        except:

            log.error(traceback.format_exc())

            self.sa.rollback()

            raise

    def delete_perm_user(self, form_data, repo_name):

        try:

            self.sa.query(RepoToPerm)\

                .filter(RepoToPerm.repository == self.get(repo_name))\

                .filter(RepoToPerm.user_id == form_data['user_id']).delete()

            self.sa.commit()

        except:

            log.error(traceback.format_exc())

            self.sa.rollback()

            raise

        from rhodecode.lib.utils import check_repo

        repo_path = os.path.join(g.base_path, repo_name)

        if check_repo(repo_name, g.base_path):

            log.info('creating repo %s in %s', repo_name, repo_path)

    def __rename_repo(self, old, new):

        log.info('renaming repo from %s to %s', old, new)

        old_path = os.path.join(g.base_path, old)

        new_path = os.path.join(g.base_path, new)

        if os.path.isdir(new_path):

            raise Exception('Was trying to rename to already existing dir %s',

                            new_path)

        shutil.move(old_path, new_path)

    def __delete_repo(self, name):

        rm_path = os.path.join(g.base_path, name)

        log.info("Removing %s", rm_path)

        #disable hg 

        shutil.move(os.path.join(rm_path, '.hg'), os.path.join(rm_path, 'rm__.hg'))

        #disable repo

        shutil.move(rm_path, os.path.join(g.base_path, 'rm__%s__%s' \

                                          % (datetime.today(), name)))

</%def>

<%def name="page_nav()">

	${self.menu('admin')}

</%def>

<%def name="main()">

<div class="box">

    <!-- box / title -->

    <div class="title">

        ${self.breadcrumbs()}      

    </div>

    ${h.form(url('repos'))}

    <div class="form">

        <!-- fields -->

        <div class="fields">

            <div class="field">

	            <div class="label">

	                <label for="repo_name">${_('Name')}:</label>

	            </div>

	            <div class="input">

	                ${h.text('repo_name',c.new_repo,class_="small")}

	            </div>

             </div>

            <div class="field">

                <div class="label label-textarea">

                    <label for="description">${_('Description')}:</label>

                </div>

                <div class="textarea text-area editor">

                    ${h.textarea('description',cols=23,rows=5)}

                </div>

             </div>

            <div class="field">

                <div class="label label-checkbox">

                    <label for="private">${_('Private')}:</label>

                </div>

                <div class="checkboxes">

                    ${h.checkbox('private',value="True")}

                </div>

             </div>

	        <div class="buttons">

	          ${h.submit('add','add',class_="ui-button ui-widget ui-state-default ui-corner-all")}

	        </div>                                                          

        </div>

    </div>    

    ${h.end_form()}    

</div>

</%def>   

<%def name="page_nav()">

	${self.menu('admin')}

</%def>

<%def name="main()">

<div class="box">

    <!-- box / title -->

    <div class="title">

        ${self.breadcrumbs()}      

    </div>

    ${h.form(url('repos'))}

    <div class="form">

        <!-- fields -->

        <div class="fields">

            <div class="field">

	            <div class="label">

	                <label for="repo_name">${_('Name')}:</label>

	            </div>

	            <div class="input">

	                ${h.text('repo_name',c.new_repo,class_="small")}

	                ${h.hidden('user_created','True')}

	            </div>

             </div>

            <div class="field">

                <div class="label label-textarea">

                    <label for="description">${_('Description')}:</label>

                </div>

                <div class="textarea text-area editor">

                    ${h.textarea('description',cols=23,rows=5)}

                </div>

             </div>

            <div class="field">

                <div class="label label-checkbox">

                    <label for="private">${_('Private')}:</label>

                </div>

                <div class="checkboxes">

                    ${h.checkbox('private',value="True")}

                </div>

             </div>

	        <div class="buttons">

	          ${h.submit('add','add',class_="ui-button ui-widget ui-state-default ui-corner-all")}

	        </div>                                                          

        </div>

    </div>    

    ${h.end_form()}    

</div>

</%def>   

</%def>

<%def name="page_nav()">

	${self.menu('admin')}

</%def>

<%def name="main()">

<div class="box">

    <!-- box / title -->

    <div class="title">

        ${self.breadcrumbs()}      

    </div>

    ${h.form(url('repo', repo_name=c.repo_info.repo_name),method='put')}

    <div class="form">

        <!-- fields -->

        <div class="fields">

            <div class="field">

                <div class="label">

                    <label for="repo_name">${_('Name')}:</label>

                </div>

                <div class="input input-medium">

                    ${h.text('repo_name',class_="small")}

                </div>

             </div>

            <div class="field">

                <div class="label label-textarea">

                    <label for="description">${_('Description')}:</label>

                </div>

                <div class="textarea text-area editor">

                    ${h.textarea('description',cols=23,rows=5)}

                </div>

            </div>

            <div class="field">

                <div class="label label-checkbox">

                    <label for="private">${_('Private')}:</label>

                </div>

                <div class="checkboxes">

                    ${h.checkbox('private',value="True")}

                </div>

            </div>

            <div class="field">

                <div class="label">

                    <label for="user">${_('Owner')}:</label>

                </div>

                <div class="input input-small ac">

                    <div class="perm_ac">

    ${h.link_to(c.repo_info.repo_name,h.url('summary_home',repo_name=c.repo_info.repo_name))} 

    »

    ${_('fork')}

</%def>

<%def name="page_nav()">

	${self.menu('')}

</%def>

<%def name="main()">

<div class="box">

    <!-- box / title -->

    <div class="title">

        ${self.breadcrumbs()}      

    </div>

    ${h.form(url('repo_fork_create_home',repo_name=c.repo_info.repo_name))}

    <div class="form">

        <!-- fields -->

        <div class="fields">

            <div class="field">

	            <div class="label">

	                <label for="repo_name">${_('Fork name')}:</label>

	            </div>

	            <div class="input">

	                ${h.text('fork_name',class_="small")}

	            </div>

             </div>

            <div class="field">

                <div class="label label-textarea">

                    <label for="description">${_('Description')}:</label>

                </div>

                <div class="textarea text-area editor">

                    ${h.textarea('description',cols=23,rows=5)}

                </div>

             </div>

            <div class="field">

                <div class="label label-checkbox">

                    <label for="private">${_('Private')}:</label>

                </div>

                <div class="checkboxes">

                    ${h.checkbox('private',value="True")}

                </div>

             </div>

	        <div class="buttons">

	          ${h.submit('','fork this repository',class_="ui-button ui-widget ui-state-default ui-corner-all")}

	        </div>                                                          

        </div>

    </div>    

    ${h.end_form()}    

from rhodecode.tests import *

from rhodecode.model.db import User

from rhodecode.lib.auth import check_password

class TestLoginController(TestController):

    def test_index(self):

        response = self.app.get(url(controller='login', action='index'))

        assert response.status == '200 OK', 'Wrong response from login page got %s' % response.status

        # Test response...

    def test_login_admin_ok(self):

        response = self.app.post(url(controller='login', action='index'),

                                 {'username':'test_admin',

                                  'password':'test12'})

        assert response.status == '302 Found', 'Wrong response code from login got %s' % response.status

        assert response.session['rhodecode_user'].username == 'test_admin', 'wrong logged in user'

        response = response.follow()

    def test_login_regular_ok(self):

        response = self.app.post(url(controller='login', action='index'),

                                 {'username':'test_regular',

                                  'password':'test12'})

        print response

        assert response.status == '302 Found', 'Wrong response code from login got %s' % response.status

        assert response.session['rhodecode_user'].username == 'test_regular', 'wrong logged in user'

        response = response.follow()

        assert '<a title="Admin" href="/_admin">' not in response.body

    def test_login_ok_came_from(self):

        test_came_from = '/_admin/users'

        response = self.app.post(url(controller='login', action='index', came_from=test_came_from),

                                 {'username':'test_admin',

                                  'password':'test12'})

        assert response.status == '302 Found', 'Wrong response code from came from redirection'

        response = response.follow()

        assert response.status == '200 OK', 'Wrong response from login page got %s' % response.status

        assert 'Users administration' in response.body, 'No proper title in response'

    def test_login_short_password(self):

        response = self.app.post(url(controller='login', action='index'),

                                 {'username':'error',

                                  'password':'test'})

        assert response.status == '200 OK', 'Wrong response from login page'

        print response.body

        assert 'Enter 6 characters or more' in response.body, 'No error password message in response'

    def test_login_wrong_username_password(self):

        response = self.app.post(url(controller='login', action='index'),

                                 {'username':'error',

                                  'password':'test12'})

        assert response.status == '200 OK', 'Wrong response from login page'

        assert 'invalid user name' in response.body, 'No error username message in response'

        assert 'invalid password' in response.body, 'No error password message in response'

    def test_register(self):

        response = self.app.get(url(controller='login', action='register'))

        assert 'Sign Up to rhodecode' in response.body, 'wrong page for user registration'