# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,

# MA  02110-1301, USA.

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

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

from rhodecode.lib.utils import get_current_revision

_rev = get_current_revision()

if len(VERSION) > 3 and _rev:

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

# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,

# MA  02110-1301, USA.

import logging

from sqlalchemy import engine_from_config

from rhodecode.lib.dbmigrate.migrate.exceptions import \

    DatabaseNotControlledError

from rhodecode.lib.utils import BasePasterCommand, Command, add_cache

log = logging.getLogger(__name__)

    group_name = "RhodeCode"

    parser = Command.standard_parser(verbose=True)

    def command(self):

        from pylons import config

        add_cache(config)

        try:

            msg = ('Found current database under version'

                 ' control with version %s' % curr_version)

        except (RuntimeError, DatabaseNotControlledError), e:

            msg = ('Current database is not under version control setting'

                   ' as version %s' % curr_version)

        print msg

    def update_parser(self):

        self.parser.add_option('--sql',

                      action='store_true',

                      dest='just_sql',

                      help="Prints upgrade sql for further investigation",

      as it was.

    :returns: A :class:`ColumnDelta` instance representing the change.

    """

    k.setdefault('alter_metadata', DEFAULT_ALTER_METADATA)

    if 'table' not in k and isinstance(p[0], sqlalchemy.Column):

        k['table'] = p[0].table

    if 'engine' not in k:

        k['engine'] = k['table'].bind

                toinit.append(column.server_default)

            else:

                toinit.append(sqlalchemy.DefaultClause(column.server_onupdate,

                                            for_update=True))

        if toinit:

            column._init_items(*toinit)

        if not SQLA_06:

            column.args = []

    def _get_table(self):

        return getattr(self, '_table', None)

    def add_to_table(self, table):

        if table is not None  and self.table is None:

            self._set_parent(table)

    def _col_name_in_constraint(self, cons, name):

        return False

    def remove_from_table(self, table, unset_table=True):

        # TODO: remove primary keys, constraints, etc

        if unset_table:

            self.table = None

        to_drop = set()

        for index in table.indexes:

            columns = []

            for col in index.columns:

                if col.name != self.name:

                    columns.append(col)

            if columns:

                index.columns = columns

            else:

                to_drop.add(index)

        table.indexes = table.indexes - to_drop

        to_drop = set()

        for cons in table.constraints:

            # TODO: deal with other types of constraint

            if isinstance(cons, (ForeignKeyConstraint,

                                UniqueConstraint)):

                for col_name in cons.columns:

                    if not isinstance(col_name, basestring):

                        col_name = col_name.name

                    if self.name == col_name:

                        to_drop.add(cons)

        table.constraints = table.constraints - to_drop

        if table.c.contains_column(self):

            table.c.remove(self)

    # TODO: this is fixed in 0.6

    def copy_fixed(self, **kw):

        """Create a copy of this ``Column``, with all attributes."""

import sys

import inspect

import logging

from rhodecode.lib.dbmigrate.migrate import exceptions

from rhodecode.lib.dbmigrate.migrate.versioning.util import catch_known_errors, with_engine

log = logging.getLogger(__name__)

command_desc = {

    'help': 'displays help on a given command',

    @classmethod

    def create(cls, path, **opts):

        """Create an empty migration script at specified path

        :returns: :class:`SqlScript instance <migrate.versioning.script.sql.SqlScript>`"""

        cls.require_notfound(path)

        src = Template(opts.pop('templates_path', None)).get_sql_script(theme=opts.pop('templates_theme', None))

        shutil.copy(src, path)

        return cls(path)

    # TODO: why is step parameter even here?

    def run(self, engine, step=None, executemany=True):

class Template(pathed.Pathed):

    """Finds the paths/packages of various Migrate templates.

    :param path: Templates are loaded from rhodecode.lib.dbmigrate.migrate package

    if `path` is not provided.

    """

    _manage = 'manage.py_tmpl'

    def __new__(cls, path=None):

        if path is None:

            path = cls._find_path(cls.pkg)

        return super(Template, cls).__new__(cls, path)

        theme = theme_mask % (theme or 'default')

        return item.get_path(theme)

    def get_repository(self, *a, **kw):

        """Calls self._get_item('repository', *a, **kw)"""

        return self._get_item('repository', *a, **kw)

    def get_script(self, *a, **kw):

        """Calls self._get_item('script', *a, **kw)"""

        return self._get_item('script', *a, **kw)

    def get_sql_script(self, *a, **kw):

        """Calls self._get_item('sql_script', *a, **kw)"""

#==============================================================================

# DB INITIAL MODEL

#==============================================================================

import logging

import datetime

from sqlalchemy import *

from sqlalchemy.exc import DatabaseError

from sqlalchemy.orm import relation, backref, class_mapper

from sqlalchemy.orm.session import Session

log = logging.getLogger(__name__)

class BaseModel(object):

    @classmethod

def upgrade(migrate_engine):

    """ Upgrade operations go here. 

    Don't create your own engine; bind migrate_engine to your metadata

    """

    #==========================================================================

    tblname = 'users'

    tbl = Table(tblname, MetaData(bind=migrate_engine), autoload=True,

                    autoload_with=migrate_engine)

    #ADD is_ldap column

                     unique=None, default=False)

    #==========================================================================

    # Upgrade of `user_logs` table

    #==========================================================================    

    tblname = 'users'

    tbl = Table(tblname, MetaData(bind=migrate_engine), autoload=True,

                    autoload_with=migrate_engine)

    #ADD repo_type column

    repo_type = Column("repo_type", String(length=None, convert_unicode=False,

                                           assert_unicode=None),

    #ADD statistics column

    enable_statistics = Column("statistics", Boolean(), nullable=True,

                               unique=None, default=True)

    enable_statistics.create(tbl)

    #==========================================================================

    # Add table `user_followings`

    #==========================================================================

    tblname = 'user_followings'

    class UserFollowing(Base, BaseModel):

        __tablename__ = 'user_followings'

        __table_args__ = (UniqueConstraint('user_id', 'follows_repository_id'),

                          UniqueConstraint('user_id', 'follows_user_id')

                          , {'useexisting':True})

    Base.metadata.tables[tblname].create(migrate_engine)

    #==========================================================================

    # Add table `cache_invalidation`

    #==========================================================================

    class CacheInvalidation(Base, BaseModel):

        __tablename__ = 'cache_invalidation'

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

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

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

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

class Repository(Base, BaseModel):

    __tablename__ = 'repositories'

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

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

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

    user_id = Column("user_id", Integer(), ForeignKey(u'users.user_id'), nullable=False, unique=False, default=None)

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

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

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

    fork_id = Column("fork_id", Integer(), ForeignKey(u'repositories.repo_id'), nullable=True, unique=False, default=None)