moved sqlalchemy session to base.

pylons_app/controllers/repos.py

@@ -1,81 +1,78 b''
 import logging
 import os
 from pylons import request, response, session, tmpl_context as c, url, app_globals as g
 from pylons.controllers.util import abort, redirect
 from pylons_app.lib import auth
 from pylons_app.lib.base import BaseController, render
-from pylons_app.model import meta
 from pylons_app.model.db import Users, UserLogs
 from pylons_app.lib.auth import authenticate
 from pylons_app.model.hg_model import HgModel
 from operator import itemgetter
 import shutil
 from pylons_app.lib.utils import invalidate_cache
 log = logging.getLogger(__name__)
 
 class ReposController(BaseController):
     """REST Controller styled on the Atom Publishing Protocol"""
     # To properly map this controller, ensure your config/routing.py
     # file has a resource setup:
     #     map.resource('repo', 'repos')
     
     @authenticate
     def __before__(self):
-        
         c.admin_user = session.get('admin_user')
         c.admin_username = session.get('admin_username')
-        self.sa = meta.Session
                 
     def index(self, format='html'):
         """GET /repos: All items in the collection"""
         # url('repos')
         hg_model = HgModel()
         c.repos_list = list(hg_model.get_repos())
         c.repos_list.sort(key=itemgetter('name'))
         return render('admin/repos/repos.html')
     
     def create(self):
         """POST /repos: Create a new item"""
         # url('repos')
 
     def new(self, format='html'):
         """GET /repos/new: Form to create a new item"""
         # url('new_repo')
 
     def update(self, id):
         """PUT /repos/id: Update an existing item"""
         # Forms posted to this method should contain a hidden field:
         #    <input type="hidden" name="_method" value="PUT" />
         # Or using helpers:
         #    h.form(url('repo', id=ID),
         #           method='put')
         # url('repo', id=ID)
 
     def delete(self, id):
         """DELETE /repos/id: Delete an existing item"""
         # Forms posted to this method should contain a hidden field:
         #    <input type="hidden" name="_method" value="DELETE" />
         # Or using helpers:
         #    h.form(url('repo', id=ID),
         #           method='delete')
         # url('repo', id=ID)
         from datetime import datetime
         path = g.paths[0][1].replace('*', '')
         rm_path = os.path.join(path, id)
         log.info("Removing %s", rm_path)
         shutil.move(os.path.join(rm_path, '.hg'), os.path.join(rm_path, 'rm__.hg'))
         shutil.move(rm_path, os.path.join(path, 'rm__%s-%s' % (datetime.today(), id)))
         
         #clear our cached list for refresh with new repo
         invalidate_cache('repo_list_2')
                     
         return redirect(url('repos'))
         
 
     def show(self, id, format='html'):
         """GET /repos/id: Show a specific item"""
         # url('repo', id=ID)
         return render('/repos_show.html')
     def edit(self, id, format='html'):
         """GET /repos/id/edit: Form to edit an existing item"""
         # url('edit_repo', id=ID)

pylons_app/controllers/users.py

@@ -1,114 +1,111 b''
 import logging
 
 from pylons import request, response, session, tmpl_context as c, url, app_globals as g
 from pylons.controllers.util import abort, redirect
 
 from pylons_app.lib.base import BaseController, render
 from formencode import htmlfill
-from pylons_app.model import meta
 from pylons_app.model.db import Users, UserLogs
 from pylons_app.lib.auth import authenticate
 import crypt
 
 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
     # file has a resource setup:
     #     map.resource('user', 'users')
     
     @authenticate
     def __before__(self):
-        
         c.admin_user = session.get('admin_user')
         c.admin_username = session.get('admin_username')
-        self.sa = meta.Session
         
     def index(self, format='html'):
         """GET /users: All items in the collection"""
         # url('users')
         
         c.users_list = self.sa.query(Users).all()     
         return render('admin/users/users.html')
     
     def create(self):
         """POST /users: Create a new item"""
         # url('users')
         params = dict(request.params)
 
         try:
             new_user = Users()
             new_user.active = params.get('active', False)
             new_user.username = params.get('username')
             new_user.password = crypt.crypt(params.get('password'), '6a')
             new_user.admin = False
             self.sa.add(new_user)
             self.sa.commit()
         except:
             self.sa.rollback()
             raise      
           
         return redirect(url('users'))
     
     def new(self, format='html'):
         """GET /users/new: Form to create a new item"""
         # url('new_user')
         return render('admin/users/user_add.html')
 
     def update(self, id):
         """PUT /users/id: Update an existing item"""
         # Forms posted to this method should contain a hidden field:
         #    <input type="hidden" name="_method" value="PUT" />
         # Or using helpers:
         #    h.form(url('user', id=ID),
         #           method='put')
         # url('user', id=ID)
         params = dict(request.params)
 
         try:
             new_user = self.sa.query(Users).get(id)
             new_user.active = params.get('active', False)
             new_user.username = params.get('username')
             if params.get('new_password'):
                 new_user.password = crypt.crypt(params.get('new_password'), '6a')
             self.sa.add(new_user)
             self.sa.commit()
         except:
             self.sa.rollback()
             raise      
           
         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:
         #    <input type="hidden" name="_method" value="DELETE" />
         # Or using helpers:
         #    h.form(url('user', id=ID),
         #           method='delete')
         # url('user', id=ID)
         try:
             self.sa.delete(self.sa.query(Users).get(id))
             self.sa.commit()
         except:
             self.sa.rollback()
             raise
         return redirect(url('users'))
         
     def show(self, id, format='html'):
         """GET /users/id: Show a specific item"""
         # url('user', id=ID)
     
     
     def edit(self, id, format='html'):
         """GET /users/id/edit: Form to edit an existing item"""
         # url('edit_user', id=ID)
         c.user = self.sa.query(Users).get(id)
         defaults = c.user.__dict__
         return htmlfill.render(
             render('admin/users/user_edit.html'),
             defaults=defaults,
             encoding="UTF-8",
             force_defaults=False
         )    

pylons_app/lib/base.py

@@ -1,27 +1,28 b''
 """The base Controller API
 
 Provides the BaseController class for subclassing.
 """
 from pylons.controllers import WSGIController
 from pylons.templating import render_mako as render
 from pylons_app.model import meta
 from beaker.cache import cache_region
 from pylons import tmpl_context as c
 from pylons_app.model.hg_model import HgModel
 
 @cache_region('long_term', 'repo_list_2')
 def _get_repos():
     return [rep['name'] for rep in HgModel().get_repos()]
 
 class BaseController(WSGIController):
         
     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']
         c.repo_list = _get_repos()
+        self.sa = meta.Session
         try:
             return WSGIController.__call__(self, environ, start_response)
         finally:
             meta.Session.remove()