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

"""

    rhodecode.__init__

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

    RhodeCode, a web based repository management based on pylons

    versioning implementation: http://semver.org/

    :created_on: Apr 9, 2010

    :author: marcink

    :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, either version 3 of the License, or

# (at your option) any later version.

#

# 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, see <http://www.gnu.org/licenses/>.

import platform

VERSION = (1, 3, 0, 'beta')

__version__ = '.'.join((str(each) for each in VERSION[:4]))

__dbversion__ = 4  # defines current db version for migrations

__platform__ = platform.system()

__license__ = 'GPLv3'

PLATFORM_WIN = ('Windows')

PLATFORM_OTHERS = ('Linux', 'Darwin', 'FreeBSD', 'OpenBSD', 'SunOS')

requirements = [

    "Pylons==1.0.0",

    "Beaker==1.6.2",

    "WebHelpers>=1.2",

    "formencode==1.2.4",

    "SQLAlchemy==0.7.3",

    "Mako==0.5.0",

    "pygments>=1.4",

    "mercurial>=2.0,<2.1",

    "whoosh<1.8",

    "celery>=2.2.5,<2.3",

    "babel",

    "python-dateutil>=1.5.0,<2.0.0",

    "dulwich>=0.8.0,<0.9.0",

    "vcs>=0.2.3.dev",

    "webob==1.0.8",

    "markdown==2.0.3",

    "docutils==0.8.1",

]

try:

    from rhodecode.lib import get_current_revision

    _rev = get_current_revision()

except ImportError:

    # this is needed when doing some setup.py operations

    _rev = False

if len(VERSION) > 3 and _rev:

    __version__ += ' [rev:%s]' % _rev[0]

def get_version():

    """Returns shorter version (digit parts only) as string."""

    return '.'.join((str(each) for each in VERSION[:3]))

BACKENDS = {

    'hg': 'Mercurial repository',

    'git': 'Git repository',

}

CELERY_ON = False

# link to config for pylons

CONFIG = None

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

"""

    rhodecode.controllers.admin.admin

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

    Controller for Admin panel of Rhodecode

    :created_on: Apr 7, 2010

    :author: marcink

    :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, either version 3 of the License, or

# (at your option) any later version.

#

# 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, see <http://www.gnu.org/licenses/>.

import logging

from pylons import request, tmpl_context as c

from sqlalchemy.orm import joinedload

from webhelpers.paginate import Page

from rhodecode.lib.auth import LoginRequired, HasPermissionAllDecorator

from rhodecode.lib.base import BaseController, render

from rhodecode.model.db import UserLog

log = logging.getLogger(__name__)

class AdminController(BaseController):

    @LoginRequired()

    def __before__(self):

        super(AdminController, self).__before__()

    @HasPermissionAllDecorator('hg.admin')

    def index(self):

        users_log = self.sa.query(UserLog)\

                .options(joinedload(UserLog.user))\

                .options(joinedload(UserLog.repository))\

                .order_by(UserLog.action_date.desc())

        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.environ.get('HTTP_X_PARTIAL_XHR'):

            return c.log_data

        return render('admin/admin.html')

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

"""

    rhodecode.controllers.admin.ldap_settings

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

    ldap controller for RhodeCode

    :created_on: Nov 26, 2010

    :author: marcink

    :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, either version 3 of the License, or

# (at your option) any later version.

#

# 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, see <http://www.gnu.org/licenses/>.

import logging

import formencode

import traceback

from formencode import htmlfill

from pylons import request, response, session, tmpl_context as c, url

from pylons.controllers.util import abort, redirect

from pylons.i18n.translation import _

from sqlalchemy.exc import DatabaseError

from rhodecode.lib.base import BaseController, render

from rhodecode.lib import helpers as h

from rhodecode.lib.auth import LoginRequired, HasPermissionAllDecorator

from rhodecode.lib.exceptions import LdapImportError

from rhodecode.model.forms import LdapSettingsForm

from rhodecode.model.db import RhodeCodeSetting

log = logging.getLogger(__name__)

class LdapSettingsController(BaseController):

    search_scope_choices = [('BASE', _('BASE'),),

                            ('ONELEVEL', _('ONELEVEL'),),

                            ('SUBTREE', _('SUBTREE'),),

                            ]

    search_scope_default = 'SUBTREE'

    tls_reqcert_choices = [('NEVER', _('NEVER'),),

                           ('ALLOW', _('ALLOW'),),

                           ('TRY', _('TRY'),),

                           ('DEMAND', _('DEMAND'),),

                           ('HARD', _('HARD'),),

                           ]

    tls_reqcert_default = 'DEMAND'

    tls_kind_choices = [('PLAIN', _('No encryption'),),

                        ('LDAPS', _('LDAPS connection'),),

                        ('START_TLS', _('START_TLS on LDAP connection'),)

                        ]

    tls_kind_default = 'PLAIN'

    @LoginRequired()

    @HasPermissionAllDecorator('hg.admin')

    def __before__(self):

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

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

        c.search_scope_choices = self.search_scope_choices

        c.tls_reqcert_choices = self.tls_reqcert_choices

        c.tls_kind_choices = self.tls_kind_choices

        c.search_scope_cur = self.search_scope_default

        c.tls_reqcert_cur = self.tls_reqcert_default

        c.tls_kind_cur = self.tls_kind_default

        super(LdapSettingsController, self).__before__()

    def index(self):

        defaults = RhodeCodeSetting.get_ldap_settings()

        c.search_scope_cur = defaults.get('ldap_search_scope')

        c.tls_reqcert_cur = defaults.get('ldap_tls_reqcert')

        c.tls_kind_cur = defaults.get('ldap_tls_kind')

        return htmlfill.render(

                    render('admin/ldap/ldap.html'),

                    defaults=defaults,

                    encoding="UTF-8",

                    force_defaults=True,)

    def ldap_settings(self):

        """POST ldap create and store ldap settings"""

        _form = LdapSettingsForm([x[0] for x in self.tls_reqcert_choices],

                                 [x[0] for x in self.search_scope_choices],

                                 [x[0] for x in self.tls_kind_choices])()

        try:

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

            try:

                for k, v in form_result.items():

                    if k.startswith('ldap_'):

                        setting = RhodeCodeSetting.get_by_name(k)

                        setting.app_settings_value = v

                        self.sa.add(setting)

                self.sa.commit()

                h.flash(_('Ldap settings updated successfully'),

                    category='success')

            except (DatabaseError,):

                raise

        except LdapImportError:

            h.flash(_('Unable to activate ldap. The "python-ldap" library '

                      'is missing.'), category='warning')

        except formencode.Invalid, errors:

            e = errors.error_dict or {}

            return htmlfill.render(

                render('admin/ldap/ldap.html'),

                defaults=errors.value,

                errors=e,

                prefix_error=False,

                encoding="UTF-8")

        except Exception:

            log.error(traceback.format_exc())

            h.flash(_('error occurred during update of ldap settings'),

                    category='error')

        return redirect(url('ldap_home'))

import logging

import traceback

from pylons import request

from pylons import tmpl_context as c, url

from pylons.controllers.util import redirect

from rhodecode.lib.base import BaseController, render

from rhodecode.model.db import Notification

from rhodecode.model.notification import NotificationModel

from rhodecode.lib.auth import LoginRequired, NotAnonymous

from rhodecode.lib import helpers as h

from rhodecode.model.meta import Session

log = logging.getLogger(__name__)

class NotificationsController(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('notification', 'notifications', controller='_admin/notifications',

    #         path_prefix='/_admin', name_prefix='_admin_')

    @LoginRequired()

    @NotAnonymous()

    def __before__(self):

        super(NotificationsController, self).__before__()

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

        """GET /_admin/notifications: All items in the collection"""

        # url('notifications')

        c.user = self.rhodecode_user

        c.notifications = NotificationModel()\

                            .get_for_user(self.rhodecode_user.user_id)

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

    def mark_all_read(self):

        if request.environ.get('HTTP_X_PARTIAL_XHR'):

            nm = NotificationModel()

            # mark all read

            nm.mark_all_read_for_user(self.rhodecode_user.user_id)

            Session.commit()

            c.user = self.rhodecode_user

            c.notifications = nm.get_for_user(self.rhodecode_user.user_id)

            return render('admin/notifications/notifications_data.html')

    def create(self):

        """POST /_admin/notifications: Create a new item"""

        # url('notifications')

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

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

        # url('new_notification')

    def update(self, notification_id):

        """PUT /_admin/notifications/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('notification', notification_id=ID),

        #           method='put')

        # url('notification', notification_id=ID)

    def delete(self, notification_id):

        """DELETE /_admin/notifications/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('notification', notification_id=ID),

        #           method='delete')

        # url('notification', notification_id=ID)

        try:

            no = Notification.get(notification_id)

            owner = lambda: (no.notifications_to_users.user.user_id

                             == c.rhodecode_user.user_id)

            if h.HasPermissionAny('hg.admin', 'repository.admin')() or owner:

                    NotificationModel().delete(c.rhodecode_user.user_id, no)

                    Session.commit()

                    return 'ok'

        except Exception:

            Session.rollback()

            log.error(traceback.format_exc())

        return 'fail'

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

        """GET /_admin/notifications/id: Show a specific item"""

        # url('notification', notification_id=ID)

        c.user = self.rhodecode_user

        no = Notification.get(notification_id)

        owner = lambda: (no.notifications_to_users.user.user_id

                         == c.user.user_id)

        if no and (h.HasPermissionAny('hg.admin', 'repository.admin')() or owner):

            unotification = NotificationModel()\

                            .get_user_notification(c.user.user_id, no)

            # if this association to user is not valid, we don't want to show

            # this message

            if unotification:

                if unotification.read is False:

                    unotification.mark_as_read()

                    Session.commit()

                c.notification = no

                return render('admin/notifications/show_notification.html')

        return redirect(url('notifications'))

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

        """GET /_admin/notifications/id/edit: Form to edit an existing item"""

        # url('edit_notification', notification_id=ID)

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

"""

    rhodecode.controllers.admin.permissions

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

    permissions controller for Rhodecode

    :created_on: Apr 27, 2010

    :author: marcink

    :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, either version 3 of the License, or

# (at your option) any later version.

#

# 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, see <http://www.gnu.org/licenses/>.

import logging

import traceback

import formencode

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 rhodecode.lib import helpers as h

from rhodecode.lib.auth import LoginRequired, HasPermissionAllDecorator

from rhodecode.lib.base import BaseController, render

from rhodecode.model.forms import DefaultPermissionsForm

from rhodecode.model.permission import PermissionModel

from rhodecode.model.db import User

from rhodecode.model.meta import Session

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

    @HasPermissionAllDecorator('hg.admin')

    def __before__(self):

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

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

        super(PermissionsController, self).__before__()

        self.perms_choices = [('repository.none', _('None'),),

                              ('repository.read', _('Read'),),

                              ('repository.write', _('Write'),),

                              ('repository.admin', _('Admin'),)]

        self.register_choices = [

            ('hg.register.none',

                _('disabled')),

            ('hg.register.manual_activate',

                _('allowed with manual account activation')),

            ('hg.register.auto_activate',

                _('allowed with automatic account activation')), ]

        self.create_choices = [('hg.create.none', _('Disabled')),

                               ('hg.create.repository', _('Enabled'))]

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

        """GET /permissions/new: Form to create a new item"""

        # url('new_permission')

    def update(self, id):

        """PUT /permissions/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('permission', id=ID),

        #           method='put')

        # url('permission', id=ID)

        permission_model = PermissionModel()

        _form = DefaultPermissionsForm([x[0] for x in self.perms_choices],

                                       [x[0] for x in self.register_choices],

                                       [x[0] for x in self.create_choices])()

        try:

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

            form_result.update({'perm_user_name': id})

            permission_model.update(form_result)

            Session.commit()

            h.flash(_('Default permissions updated successfully'),

                    category='success')

        except formencode.Invalid, errors:

            c.perms_choices = self.perms_choices

            c.register_choices = self.register_choices

            c.create_choices = self.create_choices

            defaults = errors.value

            return htmlfill.render(

                render('admin/permissions/permissions.html'),

                defaults=defaults,

                errors=errors.error_dict or {},

                prefix_error=False,

                encoding="UTF-8")

        except Exception:

            log.error(traceback.format_exc())

            h.flash(_('error occurred during update of permissions'),

                    category='error')

        return redirect(url('edit_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:

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

        #           method='delete')

        # url('permission', id=ID)

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

        #url('edit_permission', id=ID)

        c.perms_choices = self.perms_choices

        c.register_choices = self.register_choices

        c.create_choices = self.create_choices

        if id == 'default':

            default_user = User.get_by_username('default')

            defaults = {'_method': 'put',

                        'anonymous': default_user.active}

            for p in default_user.user_perms:

                if p.permission.permission_name.startswith('repository.'):

                    defaults['default_perm'] = p.permission.permission_name

                if p.permission.permission_name.startswith('hg.register.'):

                    defaults['default_register'] = p.permission.permission_name

                if p.permission.permission_name.startswith('hg.create.'):

                    defaults['default_create'] = p.permission.permission_name

            return htmlfill.render(

                        render('admin/permissions/permissions.html'),

                        defaults=defaults,

                        encoding="UTF-8",

                        force_defaults=True,)

        else:

            return redirect(url('admin_home'))

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

"""

    rhodecode.controllers.admin.repos

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

    Admin controller for RhodeCode

    :created_on: Apr 7, 2010

    :author: marcink

    :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, either version 3 of the License, or

# (at your option) any later version.

#

# 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, see <http://www.gnu.org/licenses/>.

import logging

import traceback

import formencode

from formencode import htmlfill

from paste.httpexceptions import HTTPInternalServerError

from pylons import request, session, tmpl_context as c, url

from pylons.controllers.util import redirect

from pylons.i18n.translation import _

from sqlalchemy.exc import IntegrityError

from rhodecode.lib import helpers as h

from rhodecode.lib.auth import LoginRequired, HasPermissionAllDecorator, \

    HasPermissionAnyDecorator

from rhodecode.lib.base import BaseController, render

from rhodecode.lib.utils import invalidate_cache, action_logger, repo_name_slug

from rhodecode.lib.helpers import get_token

from rhodecode.model.meta import Session

from rhodecode.model.db import User, Repository, UserFollowing, RepoGroup

from rhodecode.model.forms import RepoForm

from rhodecode.model.scm import ScmModel

from rhodecode.model.repo import RepoModel

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

    @LoginRequired()

    @HasPermissionAnyDecorator('hg.admin', 'hg.create.repository')

    def __before__(self):

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

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

        super(ReposController, self).__before__()

    def __load_defaults(self):

        c.repo_groups = RepoGroup.groups_choices()

        c.repo_groups_choices = map(lambda k: unicode(k[0]), c.repo_groups)

        repo_model = RepoModel()

        c.users_array = repo_model.get_users_js()

        c.users_groups_array = repo_model.get_users_groups_js()

    def __load_data(self, repo_name=None):

        """

        Load defaults settings for edit, and update

        :param repo_name:

        """

        self.__load_defaults()

        c.repo_info = db_repo = Repository.get_by_repo_name(repo_name)

        repo = db_repo.scm_instance

        if c.repo_info is None:

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

        c.default_user_id = User.get_by_username('default').user_id

        c.in_public_journal = UserFollowing.query()\

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

            .filter(UserFollowing.follows_repository == c.repo_info).scalar()

        if c.repo_info.stats:

            # this is on what revision we ended up so we add +1 for count

            last_rev = c.repo_info.stats.stat_on_revision + 1

        else:

            last_rev = 0

        c.stats_revision = last_rev

        c.repo_last_rev = repo.count() if repo.revisions else 0

        if last_rev == 0 or c.repo_last_rev == 0:

            c.stats_percentage = 0

        else:

            c.stats_percentage = '%.2f' % ((float((last_rev)) /

                                            c.repo_last_rev) * 100)

        defaults = RepoModel()._get_defaults(repo_name)

        c.repos_list = [('', _('--REMOVE FORK--'))]

        c.repos_list += [(x.repo_id, x.repo_name) for x in

                   Repository.query().order_by(Repository.repo_name).all()]

        return defaults

    @HasPermissionAllDecorator('hg.admin')

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

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

        # url('repos')

        c.repos_list = ScmModel().get_repos(Repository.query()

                                            .order_by(Repository.repo_name)

                                            .all(), sort_key='name_sort')

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

    @HasPermissionAnyDecorator('hg.admin', 'hg.create.repository')

    def create(self):

        """

        POST /repos: Create a new item"""

        # url('repos')

        self.__load_defaults()

        form_result = {}

        try:

            form_result = RepoForm(repo_groups=c.repo_groups_choices)()\

                            .to_python(dict(request.POST))

            RepoModel().create(form_result, self.rhodecode_user)

            if form_result['clone_uri']:

                h.flash(_('created repository %s from %s') \

                    % (form_result['repo_name'], form_result['clone_uri']),

                    category='success')

            else:

                h.flash(_('created repository %s') % form_result['repo_name'],

                    category='success')

            if request.POST.get('user_created'):

                # created by regular non admin user

                action_logger(self.rhodecode_user, 'user_created_repo',

                              form_result['repo_name_full'], '', self.sa)

            else:

                action_logger(self.rhodecode_user, 'admin_created_repo',

                              form_result['repo_name_full'], '', self.sa)

            Session.commit()

        except formencode.Invalid, errors:

            c.new_repo = errors.value['repo_name']

            if request.POST.get('user_created'):

                r = render('admin/repos/repo_add_create_repository.html')

            else:

                r = render('admin/repos/repo_add.html')

            return htmlfill.render(

                r,

                defaults=errors.value,

                errors=errors.error_dict or {},

                prefix_error=False,

                encoding="UTF-8")

        except Exception:

            log.error(traceback.format_exc())

            msg = _('error occurred during creation of repository %s') \

                    % form_result.get('repo_name')

            h.flash(msg, category='error')

        if request.POST.get('user_created'):

            return redirect(url('home'))

        return redirect(url('repos'))

    @HasPermissionAllDecorator('hg.admin')

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

        """GET /repos/new: Form to create a new item"""

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

        c.new_repo = repo_name_slug(new_repo)

        self.__load_defaults()

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

    @HasPermissionAllDecorator('hg.admin')

    def update(self, repo_name):

        """

        PUT /repos/repo_name: 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', repo_name=ID),

        #           method='put')

        # url('repo', repo_name=ID)

        self.__load_defaults()