m.connect("formatted_new_repo", "/repos/new.{format}",

             action="new", conditions=dict(method=["GET"]))

        m.connect("/repos/{repo_name:.*}",

             action="update", conditions=dict(method=["PUT"],

                                              function=check_repo))

        m.connect("/repos/{repo_name:.*}",

             action="delete", conditions=dict(method=["DELETE"],

                                              function=check_repo))

        m.connect("edit_repo", "/repos/{repo_name:.*}/edit",

             action="edit", conditions=dict(method=["GET"],

                                            function=check_repo))

        m.connect("formatted_edit_repo", "/repos/{repo_name:.*}.{format}/edit",

             action="edit", conditions=dict(method=["GET"],

                                            function=check_repo))

        m.connect("repo", "/repos/{repo_name:.*}",

             action="show", conditions=dict(method=["GET"],

                                            function=check_repo))

        m.connect("formatted_repo", "/repos/{repo_name:.*}.{format}",

             action="show", conditions=dict(method=["GET"],

                                            function=check_repo))

        #ajax delete repo perm user

        m.connect('delete_repo_user', "/repos_delete_user/{repo_name:.*}",

             action="delete_perm_user", conditions=dict(method=["DELETE"],

                                                        function=check_repo))

    #ADMIN USER REST ROUTES

    map.resource('user', 'users', controller='admin/users', path_prefix='/_admin')

    #ADMIN PERMISSIONS REST ROUTES

    map.resource('permission', 'permissions', controller='admin/permissions', path_prefix='/_admin')

    map.connect('permissions_ldap', '/_admin/permissions_ldap', controller='admin/permissions', action='ldap')

    #ADMIN SETTINGS REST ROUTES

    with map.submapper(path_prefix='/_admin', controller='admin/settings') as m:

        m.connect("admin_settings", "/settings",

             action="create", conditions=dict(method=["POST"]))

        m.connect("admin_settings", "/settings",

             action="index", conditions=dict(method=["GET"]))

        m.connect("formatted_admin_settings", "/settings.{format}",

             action="index", conditions=dict(method=["GET"]))

        m.connect("admin_new_setting", "/settings/new",

             action="new", conditions=dict(method=["GET"]))

        m.connect("formatted_admin_new_setting", "/settings/new.{format}",

             action="new", conditions=dict(method=["GET"]))

        m.connect("/settings/{setting_id}",

             action="update", conditions=dict(method=["PUT"]))

        m.connect("/settings/{setting_id}",

             action="delete", conditions=dict(method=["DELETE"]))

        except Exception, e:

            log.error(traceback.format_exc())

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

                    category='error')

        return redirect(url('repos'))

    @HasPermissionAllDecorator('hg.admin')

    def delete_perm_user(self, repo_name):

        """

        DELETE an existing repository permission user

        :param repo_name:

        """

        try:

            repo_model = RepoModel()

            repo_model.delete_perm_user(request.POST, repo_name)

        except Exception, e:

            h.flash(_('An error occured during deletion of repository user'),

                    category='error')

            raise HTTPInternalServerError()

    @HasPermissionAllDecorator('hg.admin')

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

        """GET /repos/repo_name: Show a specific item"""

        # url('repo', repo_name=ID)

    @HasPermissionAllDecorator('hg.admin')

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

        """GET /repos/repo_name/edit: Form to edit an existing item"""

        # url('edit_repo', repo_name=ID)

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

        defaults = c.repo_info.__dict__

        if c.repo_info.user:

            defaults.update({'user':c.repo_info.user.username})

        else:

            replacement_user = self.sa.query(User)\

            .filter(User.admin == True).first().username

            defaults.update({'user':replacement_user})

        c.users_array = repo_model.get_users_js()

        for p in c.repo_info.repo_to_perm:

            defaults.update({'perm_%s' % p.user.username:

                             p.permission.permission_name})

        return htmlfill.render(

            render('admin/repos/repo_edit.html'),

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

    repository_id = Column("repository_id", INTEGER(length=None, convert_unicode=False, assert_unicode=None), ForeignKey(u'repositories.repo_id'), nullable=False, unique=None, default=None)

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

    user_ip = Column("user_ip", 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)

    user = relation('User')

    repository = relation('Repository')

class Repository(Base):

    __tablename__ = 'repositories'

    __table_args__ = (UniqueConstraint('repo_name'), {'useexisting':True},)

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

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

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

    user_id = Column("user_id", INTEGER(), ForeignKey(u'users.user_id'), nullable=False, unique=False, 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)

    fork_id = Column("fork_id", INTEGER(), ForeignKey(u'repositories.repo_id'), nullable=True, unique=False, default=None)

    user = relation('User')

    fork = relation('Repository', remote_side=repo_id)

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

    def __repr__(self):

        return "<Repository('%s:%s')>" % (self.repo_id, self.repo_name)

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)

    def __repr__(self):

        return "<Permission('%s:%s')>" % (self.permission_id, self.permission_name)

class RepoToPerm(Base):

    __tablename__ = 'repo_to_perm'

    __table_args__ = (UniqueConstraint('user_id', 'repository_id'), {'useexisting':True})

    repo_to_perm_id = Column("repo_to_perm_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)

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

    repository_id = Column("repository_id", INTEGER(), ForeignKey(u'repositories.repo_id'), nullable=False, unique=None, default=None)

    user = relation('User')

    permission = relation('Permission')

# 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 vcs.backends import get_repo, get_backend

from datetime import datetime

from pylons import app_globals as g

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

        self.sa = Session()

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

        repo = self.sa.query(Repository)\

            .filter(Repository.repo_name == repo_id)

        if cache:

            repo = repo.options(FromCache("sql_cache_short",

                                          "get_repo_%s" % repo))

        return repo.scalar()

    def get_users_js(self):

        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.__delete_repo(repo)

            self.sa.commit()

        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

    def __create_repo(self, repo_name, alias):

        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)

            backend = get_backend(alias)

            backend(repo_path, create=True)

    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, repo):

        rm_path = os.path.join(g.base_path, repo.repo_name)

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

        #disable hg/git

        alias = repo.repo_type

        shutil.move(os.path.join(rm_path, '.%s' % alias),

.add_icon {

background:url("../images/icons/add.png") no-repeat scroll 3px;

height:16px;

padding-left:20px;

padding-top:1px;

text-align:left;

}

.edit_icon {

background:url("../images/icons/folder_edit.png") no-repeat scroll 3px;

height:16px;

padding-left:20px;

padding-top:1px;

text-align:left;

}

.delete_icon {

background:url("../images/icons/delete.png") no-repeat scroll 3px;

height:16px;

padding-left:20px;

padding-top:1px;

text-align:left;

}

.rss_icon {

background:url("../images/icons/rss_16.png") no-repeat scroll 3px;

height:16px;

padding-left:20px;

padding-top:1px;

text-align:left;

}

.atom_icon {

background:url("../images/icons/atom.png") no-repeat scroll 3px;

height:16px;

padding-left:20px;

padding-top:1px;

text-align:left;

}

.archive_icon {

background:url("../images/icons/compress.png") no-repeat scroll 3px;

height:16px;

padding-left:20px;

text-align:left;

padding-top:1px;

}

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

	        </div>	                                                               

        </div>

    </div>  

    ${h.end_form()}

    ##LDAP

    <h3>${_('LDAP settings')}</h3>

    ${h.form(url('permissions_ldap',id_iser='default'),method='put')}

    <div class="form">

        <div class="fields">

            <div class="field">

                <div class="label label-checkbox"><label for="ldap_active">${_('Enable ldap')}</label></div>

	            <div class="checkboxes"><div class="checkbox">${h.checkbox('ldap_active',True,class_='small')}</div></div>

            </div>

            <div class="field">

                <div class="label"><label for="ldap_host">${_('Host')}</label></div>

                <div class="input">${h.text('ldap_host',class_='small')}</div>

            </div>

            <div class="field">

                <div class="label"><label for="ldap_port">${_('Port')}</label></div>

                <div class="input">${h.text('ldap_port',class_='small')}</div>

            </div>

            <div class="field">

                <div class="checkboxes"><div class="checkbox">${h.checkbox('ldap_ldaps',True,class_='small')}</div></div>

            </div>

            <div class="field">

                <div class="label"><label for="ldap_dn_user">${_('Account')}</label></div>

                <div class="input">${h.text('ldap_dn_user',class_='small')}</div>

            </div>

            <div class="field">

                <div class="label"><label for="ldap_dn_pass">${_('Password')}</label></div>

                <div class="input">${h.password('ldap_dn_pass',class_='small')}</div>

            </div>

            <div class="field">

                <div class="label"><label for="ldap_base_dn">${_('Base DN')}</label></div>

                <div class="input">${h.text('ldap_base_dn',class_='small')}</div>

            </div>

            <div class="buttons">

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

            </div>              

        </div>

    </div>     

    ${h.end_form()}

</div>

</%def>    

                var elLI = aArgs[1]; // reference to the selected LI element

                var oData = aArgs[2]; // object literal of selected item's result data

                myAC.getInputEl().value = oData.nname;

            };

            oAC_perms.itemSelectEvent.subscribe(myHandler);

            oAC_owner.itemSelectEvent.subscribe(myHandler);

            return {

                oDS: oDS,

                oAC_perms: oAC_perms,

                oAC_owner: oAC_owner, 

            };

        }();

        </script>      

</div>

<div class="box box-right">

    <div class="title">

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

    </div>

</div>

</%def>