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

"""

    rhodecode.controllers.admin.settings

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

    settings controller for rhodecode admin

    :created_on: Jul 14, 2010

    :author: marcink

    :copyright: (C) 2010-2012 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, 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

import pkg_resources

import platform

from sqlalchemy import func

from formencode import htmlfill

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

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, \

    HasPermissionAnyDecorator, NotAnonymous

from rhodecode.lib.base import BaseController, render

from rhodecode.lib.celerylib import tasks, run_task

from rhodecode.lib.utils import repo2db_mapper, invalidate_cache, \

    set_rhodecode_config, repo_name_slug

from rhodecode.model.db import RhodeCodeUi, Repository, RepoGroup, \

    RhodeCodeSetting, PullRequest, PullRequestReviewers

from rhodecode.model.forms import UserForm, ApplicationSettingsForm, \

    ApplicationUiSettingsForm, ApplicationVisualisationForm

from rhodecode.model.scm import ScmModel

from rhodecode.model.user import UserModel

from rhodecode.model.db import User

from rhodecode.model.notification import EmailNotificationModel

from rhodecode.model.meta import Session

log = logging.getLogger(__name__)

class SettingsController(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('setting', 'settings', controller='admin/settings',

    #         path_prefix='/admin', name_prefix='admin_')

    @LoginRequired()

    def __before__(self):

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

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

        c.modules = sorted([(p.project_name, p.version)

                            for p in pkg_resources.working_set],

                           key=lambda k: k[0].lower())

        c.py_version = platform.python_version()

        c.platform = platform.platform()

        super(SettingsController, self).__before__()

    @HasPermissionAllDecorator('hg.admin')

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

        """GET /admin/settings: All items in the collection"""

        # url('admin_settings')

        defaults = RhodeCodeSetting.get_app_settings()

        return htmlfill.render(

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

            defaults=defaults,

            encoding="UTF-8",

            force_defaults=False

        )

    @HasPermissionAllDecorator('hg.admin')

    def create(self):

        """POST /admin/settings: Create a new item"""

        # url('admin_settings')

    @HasPermissionAllDecorator('hg.admin')

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

        """GET /admin/settings/new: Form to create a new item"""

        # url('admin_new_setting')

    @HasPermissionAllDecorator('hg.admin')

    def update(self, setting_id):

        """PUT /admin/settings/setting_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('admin_setting', setting_id=ID),

        #           method='put')

        # url('admin_setting', setting_id=ID)

        if setting_id == 'mapping':

            rm_obsolete = request.POST.get('destroy', False)

            log.debug('Rescanning directories with destroy=%s' % rm_obsolete)

            initial = ScmModel().repo_scan()

            log.debug('invalidating all repositories')

            for repo_name in initial.keys():

                invalidate_cache('get_repo_cached_%s' % repo_name)

            added, removed = repo2db_mapper(initial, rm_obsolete)

            h.flash(_('Repositories successfully'

                      ' rescanned added: %s,removed: %s') % (added, removed),

                      category='success')

        if setting_id == 'whoosh':

            full_index = request.POST.get('full_index', False)

            run_task(tasks.whoosh_index, repo_location, full_index)

            h.flash(_('Whoosh reindex task scheduled'), category='success')

        if setting_id == 'global':

            application_form = ApplicationSettingsForm()()

            try:

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

            except formencode.Invalid, errors:

                return htmlfill.render(

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

                     defaults=errors.value,

                     errors=errors.error_dict or {},

                     prefix_error=False,

                     encoding="UTF-8"

                )

            try:

                sett1 = RhodeCodeSetting.get_by_name_or_create('title')

                sett1.app_settings_value = form_result['rhodecode_title']

                Session().add(sett1)

                sett2 = RhodeCodeSetting.get_by_name_or_create('realm')

                sett2.app_settings_value = form_result['rhodecode_realm']

                Session().add(sett2)

                sett3 = RhodeCodeSetting.get_by_name_or_create('ga_code')

                sett3.app_settings_value = form_result['rhodecode_ga_code']

                Session().add(sett3)

                Session().commit()

                set_rhodecode_config(config)

                h.flash(_('Updated application settings'), category='success')

            except Exception:

                log.error(traceback.format_exc())

                h.flash(_('error occurred during updating '

                          'application settings'),

                          category='error')

        if setting_id == 'visual':

            application_form = ApplicationVisualisationForm()()

            try:

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

            except formencode.Invalid, errors:

                return htmlfill.render(

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

                     defaults=errors.value,

                     errors=errors.error_dict or {},

                     prefix_error=False,

                     encoding="UTF-8"

                )

            try:

                sett1 = RhodeCodeSetting.get_by_name_or_create('show_public_icon')

                sett1.app_settings_value = \

                    form_result['rhodecode_show_public_icon']

                sett2 = RhodeCodeSetting.get_by_name_or_create('show_private_icon')

                sett2.app_settings_value = \

                    form_result['rhodecode_show_private_icon']

                sett3 = RhodeCodeSetting.get_by_name_or_create('stylify_metatags')

                sett3.app_settings_value = \

                    form_result['rhodecode_stylify_metatags']

                Session().add(sett1)

                Session().add(sett2)

                Session().add(sett3)

                Session().commit()

                set_rhodecode_config(config)

                h.flash(_('Updated visualisation settings'),

                        category='success')

            except Exception:

                log.error(traceback.format_exc())

                h.flash(_('error occurred during updating '

                          'visualisation settings'),

                        category='error')

        if setting_id == 'vcs':

            application_form = ApplicationUiSettingsForm()()

            try:

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

            except formencode.Invalid, errors:

                return htmlfill.render(

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

                     defaults=errors.value,

                     errors=errors.error_dict or {},

                     prefix_error=False,

                     encoding="UTF-8"

                )

            try:

                _f = lambda s: s.replace('.', '_')

                #HOOKS

                Session().commit()

            except Exception:

                log.error(traceback.format_exc())

                h.flash(_('error occurred during updating '

                          'application settings'), category='error')

        if setting_id == 'hooks':

            ui_key = request.POST.get('new_hook_ui_key')

            ui_value = request.POST.get('new_hook_ui_value')

            try:

                if ui_value and ui_key:

                    RhodeCodeUi.create_or_update_hook(ui_key, ui_value)

                    h.flash(_('Added new hook'),

                            category='success')

                # check for edits

                update = False

                _d = request.POST.dict_of_lists()

                for k, v in zip(_d.get('hook_ui_key', []),

                                _d.get('hook_ui_value_new', [])):

                    RhodeCodeUi.create_or_update_hook(k, v)

                    update = True

                if update:

                    h.flash(_('Updated hooks'), category='success')

                Session().commit()

            except Exception:

                log.error(traceback.format_exc())

                h.flash(_('error occurred during hook creation'),

                        category='error')

            return redirect(url('admin_edit_setting', setting_id='hooks'))

        if setting_id == 'email':

            test_email = request.POST.get('test_email')

            test_email_subj = 'RhodeCode TestEmail'

            test_email_body = 'RhodeCode Email test'

            test_email_html_body = EmailNotificationModel()\

                .get_email_tmpl(EmailNotificationModel.TYPE_DEFAULT,

                                body=test_email_body)

            recipients = [test_email] if [test_email] else None

            run_task(tasks.send_email, recipients, test_email_subj,

                     test_email_body, test_email_html_body)

            h.flash(_('Email task created'), category='success')

        return redirect(url('admin_settings'))

    @HasPermissionAllDecorator('hg.admin')

    def delete(self, setting_id):

        """DELETE /admin/settings/setting_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('admin_setting', setting_id=ID),

        #           method='delete')

        # url('admin_setting', setting_id=ID)

        if setting_id == 'hooks':

            hook_id = request.POST.get('hook_id')

            RhodeCodeUi.delete(hook_id)

            Session().commit()

    @HasPermissionAllDecorator('hg.admin')

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

        """

        GET /admin/settings/setting_id: Show a specific item"""

        # url('admin_setting', setting_id=ID)

    @HasPermissionAllDecorator('hg.admin')

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

        """

        GET /admin/settings/setting_id/edit: Form to

        edit an existing item"""

        # url('admin_edit_setting', setting_id=ID)

        c.hooks = RhodeCodeUi.get_builtin_hooks()

        c.custom_hooks = RhodeCodeUi.get_custom_hooks()

        return htmlfill.render(

            render('admin/settings/hooks.html'),

            defaults={},

            encoding="UTF-8",

            force_defaults=False

        )

    @NotAnonymous()

    def my_account(self):

        """

        GET /_admin/my_account Displays info about my account

        """

        # url('admin_settings_my_account')

        c.user = User.get(self.rhodecode_user.user_id)

        all_repos = Session().query(Repository)\

                     .filter(Repository.user_id == c.user.user_id)\

                     .order_by(func.lower(Repository.repo_name)).all()

        c.user_repos = ScmModel().get_repos(all_repos)

        if c.user.username == 'default':

            h.flash(_("You can't edit this user since it's"

              " crucial for entire application"), category='warning')

            return redirect(url('users'))

        defaults = c.user.get_dict()

        c.form = htmlfill.render(

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

            defaults=defaults,

            encoding="UTF-8",

            force_defaults=False

        )

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

    @NotAnonymous()

    def my_account_update(self):

        """PUT /_admin/my_account_update: 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('admin_settings_my_account_update'),

        #           method='put')

        # url('admin_settings_my_account_update', id=ID)

        uid = self.rhodecode_user.user_id

        email = self.rhodecode_user.email

        _form = UserForm(edit=True,

                         old_data={'user_id': uid, 'email': email})()

        form_result = {}

        try:

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

            UserModel().update_my_account(uid, form_result)

            h.flash(_('Your account was updated successfully'),

                    category='success')

            Session().commit()

        except formencode.Invalid, errors:

            c.user = User.get(self.rhodecode_user.user_id)

            c.form = htmlfill.render(

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

                defaults=errors.value,

                errors=errors.error_dict or {},

                prefix_error=False,

                encoding="UTF-8")

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

        except Exception:

            log.error(traceback.format_exc())

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

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

        return redirect(url('my_account'))

    @NotAnonymous()

    def my_account_my_repos(self):

        all_repos = Session().query(Repository)\

            .filter(Repository.user_id == self.rhodecode_user.user_id)\

            .order_by(func.lower(Repository.repo_name))\

            .all()

        c.user_repos = ScmModel().get_repos(all_repos)

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

    @NotAnonymous()

    def my_account_my_pullrequests(self):

        c.my_pull_requests = PullRequest.query()\

                                .filter(PullRequest.user_id==

                                        self.rhodecode_user.user_id)\

                                .all()

        c.participate_in_pull_requests = \

            [x.pull_request for x in PullRequestReviewers.query()\

                                    .filter(PullRequestReviewers.user_id==

                                            self.rhodecode_user.user_id)\

                                    .all()]

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

    @NotAnonymous()

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

    def create_repository(self):

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

        c.repo_groups = RepoGroup.groups_choices()

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

        choices, c.landing_revs = ScmModel().get_repo_landing_revs()

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

        c.new_repo = repo_name_slug(new_repo)

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

        ret = RhodeCodeUi.query().all()

        if not ret:

            raise Exception('Could not get application ui settings !')

        settings = {}

        for each in ret:

            k = each.ui_key

            v = each.ui_value

            if k == '/':

                k = 'root_path'

            if k.find('.') != -1:

                k = k.replace('.', '_')

                v = each.ui_active

            settings[each.ui_section + '_' + k] = v

        return settings

"""The base Controller API

Provides the BaseController class for subclassing.

"""

import logging

import time

import traceback

from paste.auth.basic import AuthBasicAuthenticator

from paste.httpexceptions import HTTPUnauthorized, HTTPForbidden

from paste.httpheaders import WWW_AUTHENTICATE

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

from pylons.controllers import WSGIController

from pylons.controllers.util import redirect

from pylons.templating import render_mako as render

from rhodecode import __version__, BACKENDS

from rhodecode.lib.utils2 import str2bool, safe_unicode, AttributeDict

from rhodecode.lib.auth import AuthUser, get_container_username, authfunc,\

    HasPermissionAnyMiddleware, CookieStoreWrapper

from rhodecode.lib.utils import get_repo_slug, invalidate_cache

from rhodecode.model import meta

from rhodecode.model.db import Repository, RhodeCodeUi

from rhodecode.model.notification import NotificationModel

from rhodecode.model.scm import ScmModel

log = logging.getLogger(__name__)

def _get_ip_addr(environ):

    proxy_key = 'HTTP_X_REAL_IP'

    proxy_key2 = 'HTTP_X_FORWARDED_FOR'

    def_key = 'REMOTE_ADDR'

    ip = environ.get(proxy_key2)

    if ip:

        return ip

    ip = environ.get(proxy_key)

    if ip:

        return ip

    ip = environ.get(def_key, '0.0.0.0')

    return ip

def _get_access_path(environ):

    path = environ.get('PATH_INFO')

    org_req = environ.get('pylons.original_request')

    if org_req:

        path = org_req.environ.get('PATH_INFO')

    return path

class BasicAuth(AuthBasicAuthenticator):

    def __init__(self, realm, authfunc, auth_http_code=None):

        self.realm = realm

        self.authfunc = authfunc

        self._rc_auth_http_code = auth_http_code

    def build_authentication(self):

        head = WWW_AUTHENTICATE.tuples('Basic realm="%s"' % self.realm)

        if self._rc_auth_http_code and self._rc_auth_http_code == '403':

            # return 403 if alternative http return code is specified in

            # RhodeCode config

            return HTTPForbidden(headers=head)

        return HTTPUnauthorized(headers=head)

class BaseVCSController(object):

    def __init__(self, application, config):

        self.application = application

        self.config = config

        # base path of repo locations

        self.basepath = self.config['base_path']

        #authenticate this mercurial request using authfunc

        self.authenticate = BasicAuth('', authfunc,

                                      config.get('auth_ret_code'))

        self.ipaddr = '0.0.0.0'

    def _handle_request(self, environ, start_response):

        raise NotImplementedError()

    def _get_by_id(self, repo_name):

        """

        Get's a special pattern _<ID> from clone url and tries to replace it

        with a repository_name for support of _<ID> non changable urls

        :param repo_name:

        """

        try:

            data = repo_name.split('/')

            if len(data) >= 2:

                by_id = data[1].split('_')

                if len(by_id) == 2 and by_id[1].isdigit():

                    _repo_name = Repository.get(by_id[1]).repo_name

                    data[1] = _repo_name

        except:

            log.debug('Failed to extract repo_name from id %s' % (

                      traceback.format_exc()

                      )

            )

        return '/'.join(data)

    def _invalidate_cache(self, repo_name):

        """

        Set's cache for this repository for invalidation on next access

        :param repo_name: full repo name, also a cache key

        """

        invalidate_cache('get_repo_cached_%s' % repo_name)

    def _check_permission(self, action, user, repo_name):

        """

        Checks permissions using action (push/pull) user and repository

        name

        :param action: push or pull action

        :param user: user instance

        :param repo_name: repository name

        """

        if action == 'push':

            if not HasPermissionAnyMiddleware('repository.write',

                                              'repository.admin')(user,

                                                                  repo_name):

                return False

        else:

            #any other action need at least read permission

            if not HasPermissionAnyMiddleware('repository.read',

                                              'repository.write',

                                              'repository.admin')(user,

                                                                  repo_name):

                return False

        return True

    def _get_ip_addr(self, environ):

        return _get_ip_addr(environ)

    def _check_ssl(self, environ, start_response):

        """

        Checks the SSL check flag and returns False if SSL is not present

        and required True otherwise

        """

        org_proto = environ['wsgi._org_proto']

        #check if we have SSL required  ! if not it's a bad request !

        if require_ssl and org_proto == 'http':

            log.debug('proto is %s and SSL is required BAD REQUEST !'

                      % org_proto)

            return False

        return True

    def __call__(self, environ, start_response):

        start = time.time()

        try:

            return self._handle_request(environ, start_response)

        finally:

            log = logging.getLogger('rhodecode.' + self.__class__.__name__)

            log.debug('Request time: %.3fs' % (time.time() - start))

            meta.Session.remove()

class BaseController(WSGIController):

    def __before__(self):

        c.rhodecode_version = __version__

        c.rhodecode_instanceid = config.get('instance_id')

        c.rhodecode_name = config.get('rhodecode_title')

        c.use_gravatar = str2bool(config.get('use_gravatar'))

        c.ga_code = config.get('rhodecode_ga_code')

        # Visual options

        c.visual = AttributeDict({})

        c.visual.show_public_icon = str2bool(config.get('rhodecode_show_public_icon'))

        c.visual.show_private_icon = str2bool(config.get('rhodecode_show_private_icon'))

        c.visual.stylify_metatags = str2bool(config.get('rhodecode_stylify_metatags'))

        c.repo_name = get_repo_slug(request)

        c.backends = BACKENDS.keys()

        c.unread_notifications = NotificationModel()\

                        .get_unread_cnt_for_user(c.rhodecode_user.user_id)

        self.cut_off_limit = int(config.get('cut_off_limit'))

        self.sa = meta.Session

        self.scm_model = ScmModel(self.sa)

        self.ip_addr = ''

    def __call__(self, environ, start_response):

        """Invoke the Controller"""

        # WSGIController.__call__ dispatches to the Controller method

        # the request is routed to. This routing information is

        # available in environ['pylons.routes_dict']

        start = time.time()

        try:

            self.ip_addr = _get_ip_addr(environ)

            # make sure that we update permissions each time we call controller

            api_key = request.GET.get('api_key')

            cookie_store = CookieStoreWrapper(session.get('rhodecode_user'))

            user_id = cookie_store.get('user_id', None)

            username = get_container_username(environ, config)

            auth_user = AuthUser(user_id, api_key, username)

            request.user = auth_user

            self.rhodecode_user = c.rhodecode_user = auth_user

            if not self.rhodecode_user.is_authenticated and \

                       self.rhodecode_user.user_id is not None:

                self.rhodecode_user.set_authenticated(

                    cookie_store.get('is_authenticated')

                )

            log.info('IP: %s User: %s accessed %s' % (

               self.ip_addr, auth_user, safe_unicode(_get_access_path(environ)))

            )

            return WSGIController.__call__(self, environ, start_response)

        finally:

            log.info('IP: %s Request to %s time: %.3fs' % (

                _get_ip_addr(environ),

                safe_unicode(_get_access_path(environ)), time.time() - start)

            )

            meta.Session.remove()

class BaseRepoController(BaseController):

    """

    Base class for controllers responsible for loading all needed data for

    repository loaded items are

    c.rhodecode_repo: instance of scm repository

    c.rhodecode_db_repo: instance of db

    c.repository_followers: number of followers

    c.repository_forks: number of forks

    """

    def __before__(self):

        super(BaseRepoController, self).__before__()

        if c.repo_name:

            dbr = c.rhodecode_db_repo = Repository.get_by_repo_name(c.repo_name)

            c.rhodecode_repo = c.rhodecode_db_repo.scm_instance

            if c.rhodecode_repo is None:

                log.error('%s this repository is present in database but it '

                          'cannot be created as an scm instance', c.repo_name)

                redirect(url('home'))

            # some globals counter for menu

            c.repository_followers = self.scm_model.get_followers(dbr)

            c.repository_forks = self.scm_model.get_forks(dbr)

            c.repository_pull_requests = self.scm_model.get_pull_requests(dbr)

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

"""

    rhodecode.lib.db_manage

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

    Database creation, and setup module for RhodeCode. Used for creation

    of database as well as for migration operations

    :created_on: Apr 10, 2010

    :author: marcink

    :copyright: (C) 2010-2012 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, 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 os

import sys

import uuid

import logging

from os.path import dirname as dn, join as jn

from rhodecode import __dbversion__

from rhodecode.model import meta

from rhodecode.model.user import UserModel

from rhodecode.lib.utils import ask_ok

from rhodecode.model import init_model

from rhodecode.model.db import User, Permission, RhodeCodeUi, \

    RhodeCodeSetting, UserToPerm, DbMigrateVersion, RepoGroup,\

    UserRepoGroupToPerm

from sqlalchemy.engine import create_engine

from rhodecode.model.repos_group import ReposGroupModel

log = logging.getLogger(__name__)

class DbManage(object):

    def __init__(self, log_sql, dbconf, root, tests=False):

        self.dbname = dbconf.split('/')[-1]

        self.tests = tests

        self.root = root

        self.dburi = dbconf

        self.log_sql = log_sql

        self.db_exists = False

        self.init_db()

    def init_db(self):

        engine = create_engine(self.dburi, echo=self.log_sql)

        init_model(engine)

        self.sa = meta.Session()

    def create_tables(self, override=False, defaults={}):

        """

        Create a auth database

        """

        quiet = defaults.get('quiet')

        log.info("Any existing database is going to be destroyed")

        if self.tests or quiet:

            destroy = True

        else:

            destroy = ask_ok('Are you sure to destroy old database ? [y/n]')

        if not destroy:

            sys.exit()

        if destroy:

            meta.Base.metadata.drop_all()

        checkfirst = not override

        meta.Base.metadata.create_all(checkfirst=checkfirst)

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

    def set_db_version(self):

        ver = DbMigrateVersion()

        ver.version = __dbversion__

        ver.repository_id = 'rhodecode_db_migrations'