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

    ##ADMIN LDAP SETTINGS

    routes_map.connect('ldap_settings', '/_admin/ldap', controller='admin/ldap_settings',

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

    routes_map.connect('ldap_home', '/_admin/ldap', controller='admin/ldap_settings',)

    #ADMIN SETTINGS REST ROUTES

    with routes_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"]))

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

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

        m.connect("formatted_admin_edit_setting", "/settings/{setting_id}.{format}/edit",

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

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

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

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

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

        m.connect("admin_settings_my_account", "/my_account",

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

        m.connect("admin_settings_my_account_update", "/my_account_update",

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

        m.connect("admin_settings_create_repository", "/create_repository",

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

    #ADMIN MAIN PAGES

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

        m.connect('admin_home', '', action='index')#main page

        m.connect('admin_add_repo', '/add_repo/{new_repo:[a-z0-9\. _-]*}',

                  action='add_repo')

    #USER JOURNAL

    routes_map.connect('journal', '/_admin/journal', controller='journal',)

    routes_map.connect('toggle_following', '/_admin/toggle_following', controller='journal',

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

    #SEARCH

    routes_map.connect('search', '/_admin/search', controller='search',)

    routes_map.connect('search_repo', '/_admin/search/{search_repo:.*}', controller='search')

    #LOGIN/LOGOUT/REGISTER/SIGN IN

    routes_map.connect('login_home', '/_admin/login', controller='login')

    routes_map.connect('logout_home', '/_admin/logout', controller='login', action='logout')

    routes_map.connect('register', '/_admin/register', controller='login', action='register')

    routes_map.connect('reset_password', '/_admin/password_reset', controller='login', action='password_reset')

    #FEEDS

    routes_map.connect('rss_feed_home', '/{repo_name:.*}/feed/rss',

                controller='feed', action='rss',

                conditions=dict(function=check_repo))

    routes_map.connect('atom_feed_home', '/{repo_name:.*}/feed/atom',

                controller='feed', action='atom',

                conditions=dict(function=check_repo))

    #REPOSITORY ROUTES

    routes_map.connect('changeset_home', '/{repo_name:.*}/changeset/{revision}',

                controller='changeset', revision='tip',

                conditions=dict(function=check_repo))

    routes_map.connect('raw_changeset_home', '/{repo_name:.*}/raw-changeset/{revision}',

                controller='changeset', action='raw_changeset', revision='tip',

                conditions=dict(function=check_repo))

    routes_map.connect('summary_home', '/{repo_name:.*}',

                controller='summary', conditions=dict(function=check_repo))

    routes_map.connect('summary_home', '/{repo_name:.*}/summary',

                controller='summary', conditions=dict(function=check_repo))

    routes_map.connect('shortlog_home', '/{repo_name:.*}/shortlog',

                controller='shortlog', conditions=dict(function=check_repo))

    routes_map.connect('branches_home', '/{repo_name:.*}/branches',

                controller='branches', conditions=dict(function=check_repo))

    routes_map.connect('tags_home', '/{repo_name:.*}/tags',

                controller='tags', conditions=dict(function=check_repo))

    routes_map.connect('changelog_home', '/{repo_name:.*}/changelog',

                controller='changelog', conditions=dict(function=check_repo))

    routes_map.connect('files_home', '/{repo_name:.*}/files/{revision}/{f_path:.*}',

                controller='files', revision='tip', f_path='',

                conditions=dict(function=check_repo))

    routes_map.connect('files_diff_home', '/{repo_name:.*}/diff/{f_path:.*}',

                controller='files', action='diff', revision='tip', f_path='',

                conditions=dict(function=check_repo))

# -*- coding: utf-8 -*-

"""

    rhodecode.controllers.feed

    ~~~~~~~~~~~~~~~~~~~~~~~~~~

    Feed controller for rhodecode

    :created_on: Apr 23, 2010

    :author: marcink

    :copyright: (C) 2009-2011 Marcin Kuzminski <marcin@python-works.com>    

    :license: GPLv3, see COPYING for more details.

"""

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

import logging

from pylons import url, response, tmpl_context as c

from pylons.i18n.translation import _

from rhodecode.lib.auth import LoginRequired, HasRepoPermissionAnyDecorator

from rhodecode.lib.base import BaseRepoController

from webhelpers.feedgenerator import Atom1Feed, Rss201rev2Feed

log = logging.getLogger(__name__)

class FeedController(BaseRepoController):

    @LoginRequired()

    @HasRepoPermissionAnyDecorator('repository.read', 'repository.write',

                                   'repository.admin')

    def __before__(self):

        super(FeedController, self).__before__()

        #common values for feeds

        self.description = _('Changes on %s repository')

        self.language = 'en-us'

        self.ttl = "5"

        self.feed_nr = 10

    def atom(self, repo_name):

        """Produce an atom-1.0 feed via feedgenerator module"""

        feed = Atom1Feed(title=self.title % repo_name,

                         link=url('summary_home', repo_name=repo_name, qualified=True),

                         description=self.description % repo_name,

                         language=self.language,

                         ttl=self.ttl)

        for cs in c.rhodecode_repo[:self.feed_nr]:

            feed.add_item(title=cs.message,

                          link=url('changeset_home', repo_name=repo_name,

                                   revision=cs.raw_id, qualified=True),

                                   description=str(cs.date))

        response.content_type = feed.mime_type

        return feed.writeString('utf-8')

    def rss(self, repo_name):

        """Produce an rss2 feed via feedgenerator module"""

        feed = Rss201rev2Feed(title=self.title % repo_name,

                         link=url('summary_home', repo_name=repo_name, qualified=True),

                         description=self.description % repo_name,

                         language=self.language,

                         ttl=self.ttl)

        for cs in c.rhodecode_repo[:self.feed_nr]:

            feed.add_item(title=cs.message,

                          link=url('changeset_home', repo_name=repo_name,

                                   revision=cs.raw_id, qualified=True),

                          description=str(cs.date))

        response.content_type = feed.mime_type

        return feed.writeString('utf-8')

# -*- coding: utf-8 -*-

"""

    rhodecode.controllers.journal

    ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

    Journal controller for pylons

    :created_on: Nov 21, 2010

    :author: marcink

    :copyright: (C) 2009-2011 Marcin Kuzminski <marcin@python-works.com>    

    :license: GPLv3, see COPYING for more details.

"""

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

import logging

from sqlalchemy import or_

from sqlalchemy.orm import joinedload, make_transient

from webhelpers.paginate import Page

from itertools import groupby

from paste.httpexceptions import HTTPInternalServerError

from rhodecode.lib.auth import LoginRequired, NotAnonymous

from rhodecode.lib.base import BaseController, render

from rhodecode.model.db import UserLog, UserFollowing

log = logging.getLogger(__name__)

class JournalController(BaseController):

    @LoginRequired()

    def __before__(self):

        super(JournalController, self).__before__()

    @NotAnonymous()

    def index(self):

        # Return a rendered template

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

        c.following = self.sa.query(UserFollowing)\

            .filter(UserFollowing.user_id == c.rhodecode_user.user_id)\

            .options(joinedload(UserFollowing.follows_repository))\

            .all()

        journal = self._get_journal_data(c.following)

        c.journal_pager = Page(journal, page=p, items_per_page=20)

        c.journal_day_aggreagate = self._get_daily_aggregate(c.journal_pager)

        c.journal_data = render('journal/journal_data.html')

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

            return c.journal_data

        return render('journal/journal.html')

    def _get_daily_aggregate(self, journal):

        groups = []

        for k, g in groupby(journal, lambda x:x.action_as_day):

            user_group = []

            for k2, g2 in groupby(list(g), lambda x:x.user.email):

                l = list(g2)

                user_group.append((l[0].user, l))

            groups.append((k, user_group,))

        return groups

    def _get_journal_data(self, following_repos):

        repo_ids = [x.follows_repository.repo_id for x in following_repos

                    if x.follows_repository is not None]

        user_ids = [x.follows_user.user_id for x in following_repos

                    if x.follows_user is not None]

        filtering_criterion = None

        if repo_ids and user_ids:

            filtering_criterion = or_(UserLog.repository_id.in_(repo_ids),

                        UserLog.user_id.in_(user_ids))

        if repo_ids and not user_ids:

            filtering_criterion = UserLog.repository_id.in_(repo_ids)

        if not repo_ids and user_ids:

            filtering_criterion = UserLog.user_id.in_(user_ids)

        if filtering_criterion is not None:

            journal = self.sa.query(UserLog)\

                .options(joinedload(UserLog.user))\

                .options(joinedload(UserLog.repository))\

                .filter(filtering_criterion)\

                .order_by(UserLog.action_date.desc())

        else:

            journal = []

        return journal

    @NotAnonymous()

    def toggle_following(self):

        cur_token = request.POST.get('auth_token')

        if cur_token == token:

            user_id = request.POST.get('follows_user_id')

            if user_id:

                try:

                    self.scm_model.toggle_following_user(user_id,

                                                    c.rhodecode_user.user_id)

                    return 'ok'

                except:

                    raise HTTPInternalServerError()

            repo_id = request.POST.get('follows_repo_id')

            if repo_id:

                try:

                    self.scm_model.toggle_following_repo(repo_id,

                                                    c.rhodecode_user.user_id)

                    return 'ok'

                except:

                    raise HTTPInternalServerError()

        log.debug('token mismatch %s vs %s', cur_token, token)

        raise HTTPInternalServerError()

    def public_journal(self):

        # Return a rendered template

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

        c.following = self.sa.query(UserFollowing)\

            .filter(UserFollowing.user_id == c.rhodecode_user.user_id)\

            .options(joinedload(UserFollowing.follows_repository))\

            .all()

        journal = self._get_journal_data(c.following)

        c.journal_pager = Page(journal, page=p, items_per_page=20)

        c.journal_day_aggreagate = self._get_daily_aggregate(c.journal_pager)

        c.journal_data = render('journal/journal_data.html')

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

            return c.journal_data

        return render('journal/public_journal.html')

    app_settings_name = Column("app_settings_name", String(length=None, convert_unicode=False, assert_unicode=None), nullable=True, unique=None, default=None)

    app_settings_value = Column("app_settings_value", String(length=None, convert_unicode=False, assert_unicode=None), nullable=True, unique=None, default=None)

    def __init__(self, k='', v=''):

        self.app_settings_name = k

        self.app_settings_value = v

    def __repr__(self):

        return "<%s('%s:%s')>" % (self.__class__.__name__,

                                  self.app_settings_name, self.app_settings_value)

class RhodeCodeUi(Base):

    __tablename__ = 'rhodecode_ui'

    __table_args__ = {'useexisting':True}

    ui_id = Column("ui_id", Integer(), nullable=False, unique=True, default=None, primary_key=True)

    ui_section = Column("ui_section", String(length=None, convert_unicode=False, assert_unicode=None), nullable=True, unique=None, default=None)

    ui_key = Column("ui_key", String(length=None, convert_unicode=False, assert_unicode=None), nullable=True, unique=None, default=None)

    ui_value = Column("ui_value", String(length=None, convert_unicode=False, assert_unicode=None), nullable=True, unique=None, default=None)

    ui_active = Column("ui_active", Boolean(), nullable=True, unique=None, default=True)

class User(Base):

    __tablename__ = 'users'

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

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

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

    password = Column("password", String(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=False)

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

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

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

    ldap_dn = Column("ldap_dn", String(length=None, convert_unicode=False, assert_unicode=None), nullable=True, unique=None, default=None)

    user_log = relationship('UserLog', cascade='all')

    user_perms = relationship('UserToPerm', primaryjoin="User.user_id==UserToPerm.user_id", cascade='all')

    repositories = relationship('Repository')

    user_followers = relationship('UserFollowing', primaryjoin='UserFollowing.follows_user_id==User.user_id', cascade='all')

    group_member = relationship('UsersGroupMember', cascade='all')

    @property

    def full_contact(self):

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

    @property

    def is_admin(self):

        return self.admin

    def __repr__(self):

        return "<%s('id:%s:%s')>" % (self.__class__.__name__,

                                     self.user_id, self.username)

    @classmethod

    def by_username(cls, username):

        return Session.query(cls).filter(cls.username == username).one()

    def update_lastlogin(self):

        """Update user lastlogin"""

        try:

            session = Session.object_session(self)

            self.last_login = datetime.datetime.now()

            session.add(self)

            session.commit()

            log.debug('updated user %s lastlogin', self.username)

        except (DatabaseError,):

            session.rollback()

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('users.user_id'), nullable=False, unique=None, default=None)

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

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

    user_ip = Column("user_ip", String(length=None, convert_unicode=False, assert_unicode=None), nullable=True, unique=None, default=None)

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

    @property

    def action_as_day(self):

        return date(*self.action_date.timetuple()[:3])

    user = relationship('User')

    repository = relationship('Repository')

class UsersGroup(Base):

    __tablename__ = 'users_groups'

    __table_args__ = {'useexisting':True}

#content div.box {

clear:both;

overflow:hidden;

background:#fff;

margin:0 0 10px;

padding:0 0 10px;

}

#content div.box-left {

width:49%;

clear:none;

float:left;

margin:0 0 10px;

}

#content div.box-right {

width:49%;

clear:none;

float:right;

margin:0 0 10px;

}

#content div.box div.title {

clear:both;

overflow:hidden;

background:#369 url("../images/header_inner.png") repeat-x;

margin:0 0 20px;

padding:0;

}

#content div.box div.title h5 {

float:left;

border:none;

color:#fff;

text-transform:uppercase;

margin:0;

padding:11px 0 11px 10px;

}

#content div.box div.title ul.links li {

list-style:none;

float:left;

margin:0;

padding:0;

}

#content div.box div.title ul.links li a {

}

#content div.box h1,#content div.box h2,#content div.box h3,#content div.box h4,#content div.box h5,#content div.box h6 {

clear:both;

overflow:hidden;

border-bottom:1px solid #DDD;

margin:10px 20px;

padding:0 0 15px;

}

#content div.box p {

color:#5f5f5f;

font-size:12px;

line-height:150%;

margin:0 24px 10px;

padding:0;

}

#content div.box blockquote {

border-left:4px solid #DDD;

color:#5f5f5f;

font-size:11px;

line-height:150%;

margin:0 34px;

padding:0 0 0 14px;

}

#content div.box blockquote p {

margin:10px 0;

padding:0;

}

#content div.box dl {

margin:10px 24px;

}

#content div.box dt {

font-size:12px;

margin:0;

}

#content div.box dd {

font-size:12px;

margin:0;

padding:8px 0 8px 15px;

}

#content div.box li {