# along with this program.  If not, see <http://www.gnu.org/licenses/>.

import sys

import platform

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

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

__platform__ = platform.system()

__license__ = 'GPLv3'

__py_version__ = sys.version_info

PLATFORM_WIN = ('Windows')

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

                user_attrs = {

                 'name': safe_unicode(get_ldap_attr('ldap_attr_firstname')),

                 'lastname': safe_unicode(get_ldap_attr('ldap_attr_lastname')),

                 'email': get_ldap_attr('ldap_attr_email'),

                }

                # with some random generated password

                _password = PasswordGenerator().gen_password(length=8)

                # create this user on the fly if it doesn't exist in rhodecode

                # database

                if user_model.create_ldap(username, _password, user_dn,

                                          user_attrs):

                print ('Adding additional settings into RhodeCode db')

                self.klass.fix_settings()

                print ('Adding ldap defaults')

                self.klass.create_ldap_options(skip_existing=True)

            def step_4(self):

                self.klass.create_permissions()

                self.klass.fixup_groups()

        upgrade_steps = [0] + range(curr_version + 1, __dbversion__ + 1)

        # CALL THE PROPER ORDER OF STEPS TO PERFORM FULL UPGRADE

        for step in upgrade_steps:

            print ('performing upgrade step %s' % step)

            getattr(UpgradeSteps(self), 'step_%s' % step)()

            self.sa.commit()

    def fix_repo_paths(self):

        """

        Fixes a old rhodecode version path into new one without a '*'

        """

        paths = self.sa.query(RhodeCodeUi)\

                               PrimaryKeyConstraint,

                               CheckConstraint,

                               UniqueConstraint,

                               Index)

from rhodecode.lib.dbmigrate.migrate import exceptions

class AlterTableVisitor(SchemaVisitor):

    """Common operations for ``ALTER TABLE`` statements."""

    def append(self, s):

        """Append content to the SchemaIterator's query buffer."""

        self.buffer.write(s)

        # add primary key constraint if needed

        if column.primary_key_name:

            cons = constraint.PrimaryKeyConstraint(column,

                                                   name=column.primary_key_name)

            cons.create()

class ANSIColumnDropper(AlterTableVisitor, SchemaDropper):

    """Extends ANSI SQL dropper for column dropping (``ALTER TABLE

    DROP COLUMN``).

    """

            self.append("SET DEFAULT %s" % default_text)

        else:

            self.append("DROP DEFAULT")

    def _visit_column_type(self, table, column, delta):

        type_ = delta['type']

        self.append("TYPE %s" % type_text)

    def _visit_column_name(self, table, column, delta):

        self.start_alter_table(table)

        col_name = self.preparer.quote(delta.current_name, table.quote)

        new_name = self.preparer.format_column(delta.result_column)

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

        self._visit_constraint(*p, **k)

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

        self._visit_constraint(*p, **k)

class ANSIDialect(DefaultDialect):

    columngenerator = ANSIColumnGenerator

    columndropper = ANSIColumnDropper

    schemachanger = ANSISchemaChanger

"""

   This module defines standalone schema constraint classes.

"""

from sqlalchemy import schema

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

class ConstraintChangeset(object):

    """Base class for Constraint classes."""

    def _normalize_columns(self, cols, table_name=False):

        """Given: column objects or names; return col names and

        colnames, table = self._normalize_columns(cols)

        table = kwargs.pop('table', table)

        super(PrimaryKeyConstraint, self).__init__(*colnames, **kwargs)

        if table is not None:

            self._set_parent(table)

    def autoname(self):

        """Mimic the database's automatic constraint names"""

        return "%s_pkey" % self.table.name

class ForeignKeyConstraint(ConstraintChangeset, schema.ForeignKeyConstraint):

    def __init__(self, columns, refcolumns, *args, **kwargs):

        colnames, table = self._normalize_columns(columns)

        table = kwargs.pop('table', table)

        refcolnames, reftable = self._normalize_columns(refcolumns,

                                                        table_name=True)

        if table is not None:

            self._set_parent(table)

    @property

    def referenced(self):

        return [e.column for e in self.elements]

            raise InvalidConstraintError('You must either set "name"'

                'parameter or "columns" to autogenarate it.')

        colnames, table = self._normalize_columns(cols)

        table = kwargs.pop('table', table)

        schema.CheckConstraint.__init__(self, sqltext, *args, **kwargs)

        if table is not None:

            self._set_parent(table)

        self.colnames = colnames

    def autoname(self):

        return "%(table)s_%(cols)s_check" % \

            dict(table=self.table.name, cols="_".join(self.colnames))

        super(UniqueConstraint, self).__init__(*self.colnames, **kwargs)

        if table is not None:

            self._set_parent(table)

    def autoname(self):

        """Mimic the database's automatic constraint names"""

"""

   Firebird database specific implementations of changeset classes.

"""

from sqlalchemy.databases import firebird as sa_base

from sqlalchemy.schema import PrimaryKeyConstraint

from rhodecode.lib.dbmigrate.migrate import exceptions

class FBColumnGenerator(FBSchemaGenerator, ansisql.ANSIColumnGenerator):

    """Firebird column generator implementation."""

class FBColumnDropper(ansisql.ANSIColumnDropper):

        for cons in column.table.constraints:

            if isinstance(cons,PrimaryKeyConstraint):

                # will be deleted only when the column its on

                # is deleted!

                continue

            if should_drop:

                self.start_alter_table(column)

                self.append("DROP CONSTRAINT ")

                self.append(self.preparer.format_constraint(cons))

                self.execute()

            # TODO: recreate unique constraint if it refenrences more than this column

"""

from sqlalchemy.databases import mysql as sa_base

from sqlalchemy import types as sqltypes

from rhodecode.lib.dbmigrate.migrate import exceptions

class MySQLColumnGenerator(MySQLSchemaGenerator, ansisql.ANSIColumnGenerator):

    pass

class MySQLColumnDropper(ansisql.ANSIColumnDropper):

        raise exceptions.NotSupportedError("MySQL cannot rename indexes")

class MySQLConstraintGenerator(ansisql.ANSIConstraintGenerator):

    pass

class MySQLDialect(ansisql.ANSIDialect):

    columngenerator = MySQLColumnGenerator

    columndropper = MySQLColumnDropper

    schemachanger = MySQLSchemaChanger

"""

   `PostgreSQL`_ database specific implementations of changeset classes.

   .. _`PostgreSQL`: http://www.postgresql.org/

"""

class PGColumnGenerator(PGSchemaGenerator, ansisql.ANSIColumnGenerator):

    """PostgreSQL column generator implementation."""

    pass

from sqlalchemy.databases import sqlite as sa_base

from rhodecode.lib.dbmigrate.migrate import exceptions

from rhodecode.lib.dbmigrate.migrate.changeset import ansisql, SQLA_06

class SQLiteCommon(object):

    def _not_supported(self, op):

        raise exceptions.NotSupportedError("SQLite does not support "

            "%s; see http://www.sqlite.org/lang_altertable.html" % op)

            k = self.compare_2_columns(column, new_col, **k)

        return k

    def process_column(self, column):

        """Processes default values for column"""

        # XXX: this is a snippet from SA processing of positional parameters

        if column.server_default is not None:

            if isinstance(column.server_default, sqlalchemy.FetchedValue):

                toinit.append(column.server_default)

            else:

                toinit.append(sqlalchemy.DefaultClause(column.server_default))

            else:

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

                                            for_update=True))

        if toinit:

            column._init_items(*toinit)

    def _get_table(self):

        return getattr(self, '_table', None)

    def _set_table(self, table):

        if isinstance(table, basestring):

            if self.alter_metadata:

        # Fix metadata registration

        self.name = name

        self.deregister()

        self._set_parent(self.metadata)

    def _meta_key(self):

        return sqlalchemy.schema._get_table_key(self.name, self.schema)

    def deregister(self):

        """Remove this table from its metadata"""

class ChangesetColumn(object):

    """Changeset extensions to SQLAlchemy columns."""

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

    """

    Return differences of model against another model.

    :return: object which will evaluate to :keyword:`True` if there \

      are differences else :keyword:`False`.

    """

class ColDiff(object):

    """

    Container for differences in one :class:`~sqlalchemy.schema.Column`

    between two :class:`~sqlalchemy.schema.Table` instances, ``A``

    engine = construct_engine(url, **kw)

    try:

        kw['engine'] = engine

        return f(*a, **kw)

    finally:

            engine.dispose()

class Memoize:

    """Memoize(fn) - an instance which acts like fn but memoizes its arguments

       Will only work on functions with non-mutable arguments

    def __repr__(self):

        return '<userGroup:%s => %s >' % (self.users_group, self.repository)

class UsersGroupToPerm(Base, BaseModel):

    __tablename__ = 'users_group_to_perm'

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

    users_group_id = Column("users_group_id", Integer(), ForeignKey('users_groups.users_group_id'), nullable=False, unique=None, default=None)

    permission_id = Column("permission_id", Integer(), ForeignKey('permissions.permission_id'), nullable=False, unique=None, default=None)

    users_group = relationship('UsersGroup')

    permission = relationship('Permission')

# 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/>.

from rhodecode.lib.dbmigrate.migrate import *

from rhodecode.lib.dbmigrate.migrate.changeset import *

log = logging.getLogger(__name__)

def upgrade(migrate_engine):

    """ Upgrade operations go here.

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

    """

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

    #ADD revision column

    revision = Column('revision', TEXT(length=None, convert_unicode=False,

                                       assert_unicode=None),

                      nullable=True, unique=None, default=None)

    revision.create(tbl)

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

    # Upgrade of `repositories` table

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

    tblname = 'repositories'

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

                    autoload_with=migrate_engine)

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

    from rhodecode.lib.dbmigrate.schema.db_1_1_0 import CacheInvalidation

    CacheInvalidation().__table__.create()

    return

def downgrade(migrate_engine):

    meta = MetaData()

    meta.bind = migrate_engine

from rhodecode.lib.dbmigrate.migrate.changeset import *

from rhodecode.model.meta import Base

log = logging.getLogger(__name__)

def upgrade(migrate_engine):

    """ Upgrade operations go here.

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

    """

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

from rhodecode.lib.dbmigrate.migrate.changeset import *

from rhodecode.model.meta import Base

log = logging.getLogger(__name__)

def upgrade(migrate_engine):

    """ Upgrade operations go here.

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

    """

    return

def downgrade(migrate_engine):

    meta = MetaData()

from vcs import get_backend

from vcs.utils.helpers import get_scm

from vcs.exceptions import VCSError

from vcs.utils.lazy import LazyProperty

from rhodecode.lib import str2bool, safe_str, get_changeset_safe, safe_unicode

from rhodecode.lib.compat import json

from rhodecode.lib.caching_query import FromCache

from rhodecode.model.meta import Base, Session

log = logging.getLogger(__name__)

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

# BASE CLASSES

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

            log.error('Perhaps this repository is in db and not in '

                      'filesystem run rescan repositories with '

                      '"destroy old data " option from admin panel')

            return

        if alias == 'hg':

            repo = backend(safe_str(repo_full_path), create=False,

                           baseui=self._ui)

            # skip hidden web repository

            if repo._get_hidden():

                return

        else:

        return q.all()

class UserRepoToPerm(Base, BaseModel):

    __tablename__ = 'repo_to_perm'

    __table_args__ = (

        {'extend_existing': True}

    )

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

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

    permission_id = Column("permission_id", Integer(), ForeignKey('permissions.permission_id'), nullable=False, unique=None, default=None)

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

    user = relationship('User')

    permission = relationship('Permission')

    @classmethod

    def create(cls, user, repository, permission):

        n = cls()

        n.user = user

        n.repository = repository