BACKENDS = {

    'hg': 'Mercurial repository',

    'git': 'Git repository',

}

CELERY_ON = False

CELERY_EAGER = False

# link to config for pylons

CONFIG = {}

# Linked module for extensions

EXTENSIONS = {}

try:

    from rhodecode.lib import get_current_revision

    _rev = get_current_revision(quiet=True)

    if _rev and len(VERSION) > 3:

        VERSION += ('%s' % _rev[0],)

except ImportError:

    pass

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

               '.'.join(VERSION[3:]))

__platform__ = platform.system()

__license__ = 'GPLv3'

__py_version__ = sys.version_info

__author__ = 'Marcin Kuzminski'

__url__ = 'http://rhodecode.org'

is_windows = __platform__ in ['Windows']

is_unix = not is_windows

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

import uuid

import logging

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

from rhodecode import __dbversion__, __py_version__

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, CacheInvalidation, UserGroup

from sqlalchemy.engine import create_engine

from rhodecode.model.repos_group import ReposGroupModel

#from rhodecode.model import meta

from rhodecode.model.meta import Session, Base

from rhodecode.model.repo import RepoModel

from rhodecode.model.permission import PermissionModel

from rhodecode.model.users_group import UserGroupModel

log = logging.getLogger(__name__)

def notify(msg):

    """

        #fix all usergroups

        ug_model = UserGroupModel()

        for ug in UserGroup.get_all():

            perm_obj = ug_model._create_default_perms(ug)

            Session().add(perm_obj)

        Session().commit()

        adm = User.get_first_admin()

        # fix owners of UserGroup

        for ug in Session().query(UserGroup).all():

            ug.user_id = adm.user_id

            Session().add(ug)

        Session().commit()

        # fix owners of RepoGroup

        for ug in Session().query(RepoGroup).all():

            ug.user_id = adm.user_id

            Session().add(ug)

        Session().commit()

    def step_13(self):

        pass

class DbManage(object):

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

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

        self.tests = tests

        self.root = root

        self.dburi = dbconf

        self.log_sql = log_sql

        self.db_exists = False

        self.cli_args = cli_args

        self.init_db()

        force_ask = self.cli_args.get('force_ask')

        if force_ask is not None:

            global ask_ok

            ask_ok = lambda *args, **kwargs: force_ask

    def init_db(self):

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

        init_model(engine)

        self.sa = Session()

    def create_tables(self, override=False):

        """