cleared prints leftoovers, and changed current user fetching in login controller

pylons_app/controllers/login.py

@@ -1,37 +1,38 b''
 import logging
 from formencode import htmlfill
 from pylons import request, response, session, tmpl_context as c, url
 from pylons.controllers.util import abort, redirect
 from pylons_app.lib.base import BaseController, render
 import formencode
 from pylons_app.model.forms import LoginForm
 from pylons_app.lib.auth import AuthUser
 
 log = logging.getLogger(__name__)
 
 class LoginController(BaseController):
 
     def index(self):
-        if session.get('hg_app_user', AuthUser()).is_authenticated:
+        #redirect if already logged in
+        if c.hg_app_user.is_authenticated:
             return redirect(url('hg_home'))
         
         if request.POST:
             #import Login Form validator class
             login_form = LoginForm()
             try:
                 c.form_result = login_form.to_python(dict(request.POST))
                 return redirect(url('hg_home'))
                                
             except formencode.Invalid as errors:
                 c.form_errors = errors.error_dict
                 return htmlfill.render(
                     render('/login.html'),
                     defaults=errors.value,
                     encoding="UTF-8")
                         
         return render('/login.html')
     
     def logout(self):
         session['hg_app_user'] = AuthUser()
         session.save()
         redirect(url('hg_home'))

pylons_app/model/forms.py

@@ -1,126 +1,125 b''
 """ this is forms validation classes
 http://formencode.org/module-formencode.validators.html
 for list off all availible validators
 
 we can create our own validators
 
 The table below outlines the options which can be used in a schema in addition to the validators themselves
 pre_validators          []     These validators will be applied before the schema
 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.validators import UnicodeString, OneOf, Int, Number, Regex
 from pylons import session
 from pylons.i18n.translation import _
 from pylons_app.lib.auth import get_crypt_password
 from pylons_app.model import meta
 from pylons_app.model.db import Users
 from sqlalchemy.exc import OperationalError
 from sqlalchemy.orm.exc import NoResultFound, MultipleResultsFound
 from webhelpers.pylonslib.secure_form import authentication_token
 import formencode
 import logging
 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)
 
 class ValidAuth(formencode.validators.FancyValidator):
     messages = {
             'invalid_password':_('invalid password'),
             'invalid_login':_('invalid user name'),
             'disabled_account':_('Your acccount is disabled')
             
             }
     #error mapping
     e_dict = {'username':messages['invalid_login'],
               'password':messages['invalid_password']}
     
     def validate_python(self, value, state):
         sa = meta.Session
         crypted_passwd = get_crypt_password(value['password'])
         username = value['username']
         try:
             user = sa.query(Users).filter(Users.username == username).one()
         except (NoResultFound, MultipleResultsFound, OperationalError) as e:
             log.error(e)
             user = None
-        print value
         if user:
             if user.active:
                 if user.username == username and user.password == crypted_passwd:
                     log.info('user %s authenticated correctly', username)
                     from pylons_app.lib.auth import AuthUser
                     auth_user = AuthUser()
                     auth_user.username = username
                     auth_user.is_authenticated = True
                     auth_user.is_admin = user.admin
                     session['hg_app_user'] = auth_user
                     session.save()
                     return value
                 else:
                     log.warning('user %s not authenticated', username)
                     raise formencode.Invalid(self.message('invalid_password',
                                              state=State_obj), value, state,
                                              error_dict=self.e_dict)
             else:
                 log.warning('user %s is disabled', username)
                 raise formencode.Invalid(self.message('disabled_account',
                                          state=State_obj),
                                          value, state, error_dict=self.e_dict)
             
             
         
 #===============================================================================
 # FORMS        
 #===============================================================================
 class LoginForm(formencode.Schema):
     allow_extra_fields = True
     filter_extra_fields = True
     username = UnicodeString(
                              strip=True,
                              min=3,
                              not_empty=True,
                              messages={
                                        'empty':_('Please enter a login'),
                                        'tooShort':_('Enter a value %(min)i characters long or more')}
                             )
 
     password = UnicodeString(
                             strip=True,
                             min=3,
                             not_empty=True,
                             messages={
                                       'empty':_('Please enter a password'),
                                       'tooShort':_('Enter a value %(min)i characters long or more')}
                                 )
 
 
     #chained validators have access to all data
     chained_validators = [ValidAuth]
     
 

pylons_app/model/hg_model.py

@@ -1,66 +1,67 b''
 #!/usr/bin/env python
 # encoding: utf-8
 #
 # Copyright (c) 2010 marcink.  All rights reserved.
 #
 from vcs.exceptions import RepositoryError
 '''
 Created on Apr 9, 2010
 
 @author: marcink
 '''
 import os
 from pylons import tmpl_context as c, app_globals as g, session, request, config
 from pylons.controllers.util import abort
+import sys
 try:
     from vcs.backends.hg import get_repositories, MercurialRepository
 except ImportError:
-    print 'You have to import vcs module'
+    sys.stderr.write('You have to import vcs module')
     raise Exception('Unable to import vcs')
 
 class HgModel(object):
     """
     Mercurial Model
     """
 
 
     def __init__(self):
         """
         Constructor
         """
         pass
 
     def get_repos(self):
         for mercurial_repo in get_repositories(g.paths[0][0], g.paths[0][1], g.baseui):
             
             if mercurial_repo._get_hidden():
                 #skip hidden web repository
                 continue
             
             last_change = mercurial_repo.last_change
             try:
                 tip = mercurial_repo.get_changeset('tip')
             except RepositoryError:
                 from pylons_app.lib.utils import EmptyChangeset
                 tip = EmptyChangeset()
                 
             tmp_d = {}
             tmp_d['name'] = mercurial_repo.name
             tmp_d['name_sort'] = tmp_d['name']
             tmp_d['description'] = mercurial_repo.description
             tmp_d['description_sort'] = tmp_d['description']
             tmp_d['last_change'] = last_change
             tmp_d['last_change_sort'] = last_change[1] - last_change[0]
             tmp_d['tip'] = tip.raw_id
             tmp_d['tip_sort'] = tip.revision 
             tmp_d['rev'] = tip.revision
             tmp_d['contact'] = mercurial_repo.contact
             tmp_d['contact_sort'] = tmp_d['contact']
             tmp_d['repo_archives'] = list(mercurial_repo._get_archives())
             
             yield tmp_d
 
     def get_repo(self, repo_name):
         path = g.paths[0][1].replace('*', '')
         repo = MercurialRepository(os.path.join(path, repo_name), baseui=g.baseui)
         return repo