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.base import BaseController, render

from pylons_app.model import meta

from webhelpers.paginate import Page

from pylons_app.lib.auth import LoginRequired

log = logging.getLogger(__name__)

class AdminController(BaseController):

        c.admin_username = user.username

        super(AdminController, self).__before__()

    def index(self):

        sa = meta.Session

        p = int(request.params.get('page', 1))

        c.users_log = Page(users_log, page=p, items_per_page=10)

        c.log_data = render('admin/admin_log.html')

        if request.params.get('partial'):

            return c.log_data

        return render('admin/admin.html')    

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

import crypt

log = logging.getLogger(__name__)

class UsersController(BaseController):

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

        super(UsersController, self).__before__()

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

        """GET /users: All items in the collection"""

        # url('users')

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

    def create(self):

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

        # url('users')

        params = dict(request.params)

        try:

            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()

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

        #           method='put')

        # url('user', id=ID)

        params = dict(request.params)

        try:

            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()

        #    <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.commit()

        except:

            self.sa.rollback()

            raise

        return redirect(url('users'))

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

        defaults = c.user.__dict__

        return htmlfill.render(

            render('admin/users/user_edit.html'),

            defaults=defaults,

            encoding="UTF-8",

            force_defaults=False

from functools import wraps

from pylons import session, url

from pylons.controllers.util import abort, redirect

from pylons_app.model import meta

from sqlalchemy.exc import OperationalError

from sqlalchemy.orm.exc import NoResultFound, MultipleResultsFound

import crypt

import logging

log = logging.getLogger(__name__)

    return crypt.crypt(password, '6a')

def authfunc(environ, username, password):

    sa = meta.Session

    password_crypt = get_crypt_password(password)

    try:

    except (NoResultFound, MultipleResultsFound, OperationalError) as e:

        log.error(e)

        user = None

    if user:

        if user.active:

import logging

from os.path import dirname as dn

from sqlalchemy.engine import create_engine

import os

import sys

ROOT = dn(dn(dn(os.path.realpath(__file__))))

sys.path.append(ROOT)

from pylons_app.model.meta import Session, Base

from pylons_app.lib.auth import get_crypt_password

from pylons_app.model import init_model

log = logging.getLogger('db manage')

                                    " %(levelname)-5.5s [%(name)s] %(message)s"))

log.addHandler(console_handler)

class DbManage(object):

    def __init__(self, log_sql):

        self.dbname = 'hg_app.db'

        engine = create_engine(dburi, echo=log_sql) 

        init_model(engine)

        self.sa = Session()

    def check_for_db(self, override):

        log.info('checking for exisiting db')

            log.info('database exisist')

            if not override:

                raise Exception('database already exists')

    def create_tables(self, override=False):

        """

        Create a auth database

        """

        self.check_for_db(override)

        if override:

            log.info("database exisist and it's going to be destroyed")

        Base.metadata.create_all(checkfirst=override)

        log.info('Created tables for %s', self.dbname)

    def admin_prompt(self):

        import getpass

        username = raw_input('Specify admin username:')

        password = getpass.getpass('Specify admin password:')

        self.create_user(username, password, True)

    def create_user(self, username, password, admin=False):

        log.info('creating administrator user %s', username)

        new_user.username = username

        new_user.password = get_crypt_password(password)

        new_user.admin = admin

        new_user.active = True

        try:

from mercurial.hgweb.request import wsgiapplication

from paste.auth.basic import AuthBasicAuthenticator

from paste.httpheaders import REMOTE_USER, AUTH_TYPE

from pylons_app.lib.auth import authfunc

from pylons_app.lib.utils import is_mercurial, make_ui, invalidate_cache

from pylons_app.model import meta

from webob.exc import HTTPNotFound

import logging

import os

log = logging.getLogger(__name__)

class SimpleHg(object):

                if mapping.has_key(cmd):

                    return mapping[cmd]

    def __log_user_action(self, username, action, repo):

        sa = meta.Session

        try:

            user_log.user_id = user.user_id

            user_log.action = action

            user_log.repository = repo.replace('/', '')

            user_log.action_date = datetime.now()

            sa.add(user_log)

            sa.commit()

from pylons_app.model.meta import Base

from sqlalchemy.orm import relation, backref

from sqlalchemy import *

    __tablename__ = 'users'

    __table_args__ = {'useexisting':True}

    user_id = Column("user_id", INTEGER(), nullable=False, unique=True, default=None, primary_key=1)

    username = Column("username", TEXT(length=None, convert_unicode=False, assert_unicode=None), nullable=True, unique=None, default=None)

    password = Column("password", TEXT(length=None, convert_unicode=False, assert_unicode=None), nullable=True, unique=None, default=None)

    active = Column("active", BOOLEAN(), nullable=True, unique=None, default=None)

    admin = Column("admin", BOOLEAN(), nullable=True, unique=None, default=None)

    name = Column("name", TEXT(length=None, convert_unicode=False, assert_unicode=None), nullable=True, unique=None, default=None)

    lastname = Column("lastname", TEXT(length=None, convert_unicode=False, assert_unicode=None), nullable=True, unique=None, default=None)

    email = Column("email", TEXT(length=None, convert_unicode=False, assert_unicode=None), nullable=True, unique=None, default=None)

    last_login = Column("last_login", DATETIME(timezone=False), nullable=True, unique=None, default=None)

    def __repr__(self):

        return "<User('%s:%s')>" % (self.user_id, self.username)

    __tablename__ = 'user_logs'

    __table_args__ = {'useexisting':True}

    user_id = Column("user_id", INTEGER(), ForeignKey(u'users.user_id'), nullable=True, unique=None, default=None)

    repository = Column("repository", TEXT(length=None, convert_unicode=False, assert_unicode=None), nullable=True, unique=None, default=None)

    action = Column("action", TEXT(length=None, convert_unicode=False, assert_unicode=None), nullable=True, unique=None, default=None)

    action_date = Column("action_date", DATETIME(timezone=False), nullable=True, unique=None, default=None)

    __tablename__ = 'permissions'

    __table_args__ = {'useexisting':True}

    permission_id = Column("id", INTEGER(), nullable=False, unique=True, default=None, primary_key=1)

    permission_name = Column("permission_name", TEXT(length=None, convert_unicode=False, assert_unicode=None), nullable=True, unique=None, default=None)

    def __repr__(self):

"""

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 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__)

    def validate_python(self, value, state):

        sa = meta.Session

        crypted_passwd = get_crypt_password(value['password'])

        username = value['username']

        try:

        except (NoResultFound, MultipleResultsFound, OperationalError) as e:

            log.error(e)

            user = None

        if user:

            if user.active:

                if user.username == username and user.password == crypted_passwd: