BRAND = "kallithea"

try:

    from kallithea.brand import BRAND

except ImportError:

    pass

# Prefix for the ui and settings table names

DB_PREFIX = (BRAND + "_") if BRAND != "kallithea" else ""

# Users.extern_type and .extern_name value for local users

EXTERN_TYPE_INTERNAL = BRAND if BRAND != 'kallithea' else 'internal'

try:

    from kallithea.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])))

__dbversion__ = 31  # defines current db version for migrations

__platform__ = platform.system()

__license__ = 'GPLv3'

:copyright: (c) 2013 RhodeCode GmbH, and others.

:license: GPLv3, see LICENSE.md for more details.

"""

import os

import sys

import time

import uuid

import logging

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

import datetime

from kallithea.model.user import UserModel

from kallithea.lib.utils import ask_ok

from kallithea.model import init_model

from kallithea.model.db import User, Permission, Ui, \

    Setting, UserToPerm, DbMigrateVersion, RepoGroup, \

    UserRepoGroupToPerm, CacheInvalidation, UserGroup, Repository

from sqlalchemy.engine import create_engine

from kallithea.model.repo_group import RepoGroupModel

#from kallithea.model import meta

from kallithea.model.meta import Session, Base

from kallithea.model.repo import RepoModel

            print 'Nothing done.'

            sys.exit(0)

        if destroy:

            Base.metadata.drop_all()

        checkfirst = not override

        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_path = 'versions'

        self.sa.add(ver)

        log.info('db version set to: %s' % __dbversion__)

    def upgrade(self):

        """

        Upgrades given database schema to given revision following

        all needed steps, to perform the upgrade

        """

        from kallithea.lib.dbmigrate.migrate.versioning import api

[db_settings]

# Used to identify which repository this database is versioned under.

# You can use the name of your project.

# The name of the database table used to track the schema version.

# This name shouldn't already be used by your project.

# If this is changed once a database is under version control, you'll need to 

# change the table name in each database too. 

version_table=db_migrate_version

# When committing a change script, Migrate will attempt to generate the 

# sql for all supported databases; normally, if one of them fails - probably

# because you don't have that database installed - it is ignored and the 

# commit continues, perhaps ending successfully. 

# Databases in this list MUST compile successfully during a commit, or the 

"""

   SQLAlchemy migrate repository management.

"""

import os

import shutil

import string

import logging

from pkg_resources import resource_filename

from tempita import Template as TempitaTemplate

from kallithea.lib.dbmigrate.migrate import exceptions

from kallithea.lib.dbmigrate.migrate.versioning import version, pathed, cfgparse

from kallithea.lib.dbmigrate.migrate.versioning.template import Template

from kallithea.lib.dbmigrate.migrate.versioning.config import *

log = logging.getLogger(__name__)

class Changeset(dict):

    """A collection of changes to be applied to a database.

    Changesets are bound to a repository and manage a set of

    def latest(self):

        """API to :attr:`migrate.versioning.version.Collection.latest`"""

        return self.versions.latest

    @property

    def version_table(self):

        """Returns version_table name specified in config"""

        return self.config.get('db_settings', 'version_table')

    @property

    def id(self):

        """Returns repository id specified in config"""

    @property

    def use_timestamp_numbering(self):

        """Returns use_timestamp_numbering specified in config"""

        if self.config.has_option('db_settings', 'use_timestamp_numbering'):

            return self.config.getboolean('db_settings', 'use_timestamp_numbering')

        return False

    def version(self, *p, **k):

        """API to :attr:`migrate.versioning.version.Collection.version`"""

        return self.versions.version(*p, **k)