#!/usr/bin/env python

# encoding: utf-8

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

# MA  02110-1301, USA.

"""

Created on April 27, 2010

permissions controller for pylons

@author: marcink

"""

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.user_model import UserModel

import formencode

import logging

log = logging.getLogger(__name__)

class PermissionsController(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('permission', 'permissions')

    @LoginRequired()

    def __before__(self):

        c.admin_user = session.get('admin_user')

        c.admin_username = session.get('admin_username')

        super(PermissionsController, self).__before__()

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

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

        # url('permissions')

    def create(self):

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

        # url('permissions')

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

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

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

        # Or using helpers:

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

        #           method='put')

        # url('permission', id=ID)

    def delete(self, id):

        """DELETE /permissions/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:

    def show(self, id, format='html'):

        """GET /permissions/id: Show a specific item"""

        # url('permission', id=ID)

    def edit(self, id, format='html'):

        """GET /permissions/id/edit: Form to edit an existing item"""

    """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')

    @LoginRequired()

    def __before__(self):

        c.admin_user = session.get('admin_user')

        c.admin_username = session.get('admin_username')

        super(ReposController, self).__before__()

    @HasPermissionAllDecorator('hg.admin')            

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

        # url('repos')

        cached_repo_list = HgModel().get_repos()

        c.repos_list = sorted(cached_repo_list, key=itemgetter('name_sort'))

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

    def create(self):

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

        # url('repos')

        repo_model = RepoModel()

        _form = RepoForm()()

        form_result = {}

            log.error(traceback.format_exc())

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

                    % form_result.get('username'), category='error')

        return redirect(url('my_account'))

    def create_repository(self):

        """GET /_admin/create_repository: Form to create a new item"""

        new_repo = request.GET.get('repo', '')

        c.new_repo = h.repo_name_slug(new_repo)

        return render('admin/repos/repo_add_create_repository.html')

from pylons_app.model.forms import UserForm

from pylons_app.model.user_model import UserModel, DefaultUserException

import formencode

import logging

import traceback

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:

# 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, response, session, tmpl_context as c, url

from pylons.controllers.util import abort, redirect

from pylons_app.lib.base import BaseController, render

from pylons_app.model.forms import LoginForm, RegisterForm

from pylons_app.model.user_model import UserModel

import formencode

import logging

log = logging.getLogger(__name__)

class LoginController(BaseController):

    def __before__(self):

                    errors=errors.error_dict or {},

                    prefix_error=False,

                    encoding="UTF-8")

        return render('/login.html')

    def register(self):

        if request.POST:

            register_form = RegisterForm()()

            try:

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

                user_model.create_registration(form_result)

                return redirect(url('login_home'))

            except formencode.Invalid as errors:

                return htmlfill.render(

                    render('/register.html'),

"""

from beaker.cache import cache_region

from pylons import config, session, url, request

from pylons.controllers.util import abort, redirect

from pylons_app.lib.utils import get_repo_slug

from pylons_app.model import meta

from sqlalchemy.exc import OperationalError

from sqlalchemy.orm.exc import NoResultFound, MultipleResultsFound

import bcrypt

from decorator import decorator

import logging

    """

    sa = meta.Session

    user.permissions['repositories'] = {}

    user.permissions['global'] = set()

        .join((Repository, RepoToPerm.repository_id == Repository.repo_id))\

        .join((Permission, RepoToPerm.permission_id == Permission.permission_id))\

        .filter(RepoToPerm.user_id == sa.query(User).filter(User.username == 

                                            'default').one().user_id).all()

    if user.is_admin:

        user.permissions['global'].add('hg.admin')

        for perm in default_perms:

            p = 'repository.admin'

            user.permissions['repositories'][perm.RepoToPerm.repository.repo_name] = p

    else:

        for perm in default_perms:

            if perm.Repository.private and not perm.Repository.user_id == user.user_id:

                #disable defaults for private repos,

                p = 'repository.none'

            elif perm.Repository.user_id == user.user_id:

                #set admin if owner

                p = 'repository.admin'

            else:

                p = perm.Permission.permission_name

            user.permissions['repositories'][perm.RepoToPerm.repository.repo_name] = p

            .join((Repository, RepoToPerm.repository_id == Repository.repo_id))\

            .join((Permission, RepoToPerm.permission_id == Permission.permission_id))\

            .filter(RepoToPerm.user_id == user.user_id).all()

        for perm in user_perms:

            else:

                p = perm.Permission.permission_name

            user.permissions['repositories'][perm.RepoToPerm.repository.repo_name] = p

    meta.Session.remove()         

    return user

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

sys.path.append(ROOT)

from pylons_app.lib.auth import get_crypt_password

from pylons_app.lib.utils import ask_ok

from pylons_app.model import init_model

from pylons_app.model import meta

from sqlalchemy.engine import create_engine

import logging

log = logging.getLogger(__name__)

        #module.(access|create|change|delete)_[name]

        #module.(read|write|owner)

        perms = [('repository.none', 'Repository no access'),

                 ('repository.read', 'Repository read access'),

                 ('repository.write', 'Repository write access'),

                 ('repository.admin', 'Repository admin access'),

                 ('hg.admin', 'Hg Administrator'),

                ]

        for p in perms:

            new_perm = Permission()

            new_perm.permission_name = p[0]

            new_perm.permission_longname = p[1]

            try:

                self.sa.add(new_perm)

                self.sa.commit()

            except:

                self.sa.rollback()

                raise

    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)

    user_log = relation('UserLog')

    @LazyProperty

    def full_contact(self):

        return '%s %s <%s>' % (self.name, self.lastname, self.email)

    def __repr__(self):

class UserLog(Base): 

    __tablename__ = 'user_logs'

    __table_args__ = {'useexisting':True}

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

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

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

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

    user = relation('User')

    repo_to_perm = relation('RepoToPerm', cascade='all')

class Permission(Base):

    __tablename__ = 'permissions'

    __table_args__ = {'useexisting':True}

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

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

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

        paths_root_path = All(ValidPath(), UnicodeString(strip=True, min=3, not_empty=True))

        hooks_changegroup_update = OneOf(['True', 'False'], if_missing=False)

        hooks_changegroup_repo_size = OneOf(['True', 'False'], if_missing=False)

    return _ApplicationUiSettingsForm

"""

from datetime import datetime

from pylons import app_globals as g

from pylons_app.lib.utils import check_repo

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

from pylons_app.model.meta import Session

import logging

import os

import shutil

import traceback

log = logging.getLogger(__name__)

            new_repo.user_id = cur_user.user_id

            self.sa.add(new_repo)

            #create default permission

            repo_to_perm = RepoToPerm()

            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 = self.sa.query(User)\

class UserModel(object):

    def __init__(self):

        self.sa = Session() 

    def get_user(self, id):

        return self.sa.query(User).get(id)

    def create(self, form_data):

        try:

            new_user = User()

            raise      

    def create_registration(self, form_data):

        try:

            new_user = User()

            for k, v in form_data.items():

                    setattr(new_user, k, v)

            self.sa.add(new_user)

            self.sa.commit()

        except Exception as e:

            log.error(e)

            self.sa.rollback()

<%def name="main()">

<div class="box">

    <!-- box / title -->

    <div class="title">

        ${self.breadcrumbs()}       

    </div>

    <div class="form">

        <!-- fields -->

        <div class="fields">

			<div class="field">

				<div class="label">

				</div>

				<div class="select">

				</div>

	        <div class="buttons">

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

        </div>

    </div>  

    ${h.end_form()}

</div>

</%def>    

                   </span>

                   <span>${_('Admin')}</span>                 

                   </a>    

				    <ul>

				        <li>${h.link_to(_('repositories'),h.url('repos'),class_='repos')}</li>

				        <li>${h.link_to(_('users'),h.url('users'),class_='users')}</li>

				        <li>${h.link_to(_('settings'),h.url('admin_settings'),class_='settings')}</li>        

				    </ul>

                </li>

				%endif

			</ul>

    <div class="box">

	    <!-- box / title -->

	    <div class="title">

	        <h5>${_('Dashboard')}</h5>

	        <ul class="links">

	          <li>

	            <span>${h.link_to(u'ADD NEW REPOSITORY',h.url('admin_settings_create_repository'),class_="add_icon")}</span>

	          </li>          

	        </ul>  	        

	        %endif

                        </div>

                    </div>

                    <!-- end fields -->

                    <!-- links -->

                    <div class="links">

                        ${h.link_to(_('Forgot your password ?'),h.url('#'))}

                    </div>

                    <!-- end links -->

                </div>

                ${h.end_form()}

            </div>

			                </div>

			             </div>

			            <div class="buttons">

				            <div class="nohighlight">

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

				            </div>

			            </div>             

			    	</div>

			    </div>

			    ${h.end_form()}

			</div>    

    """Place any commands to setup pylons_app here"""

    dbmanage = DbManage(log_sql=True)

    dbmanage.create_tables(override=True)

    dbmanage.config_prompt()

    dbmanage.admin_prompt()

    dbmanage.create_permissions()

    load_environment(conf.global_conf, conf.local_conf, initial=True)